Unity 8

Merge lp:~dandrader/unity8/surfaceListModel into lp:unity8

surfaceListModel
Merge into trunk

Proposed by Daniel d'Andrada on 2016-03-29

Status:	Merged
Approved by:	Michał Sawicz on 2016-04-22
Approved revision:	2360
Merged at revision:	2336
Proposed branch:	lp:~dandrader/unity8/surfaceListModel
Merge into:	lp:unity8
Prerequisite:	lp:~dandrader/unity8/declarativeKeymap
Diff against target:	11952 lines (+4061/-2915) 78 files modified debian/control (+1/-1) debian/unity8-private.install (+1/-0) plugins/CMakeLists.txt (+1/-0) plugins/WindowManager/CMakeLists.txt (+13/-0) plugins/WindowManager/TopLevelSurfaceList.cpp (+486/-0) plugins/WindowManager/TopLevelSurfaceList.h (+223/-0) plugins/WindowManager/WindowManagerPlugin.cpp (+28/-0) plugins/WindowManager/WindowManagerPlugin.h (+32/-0) plugins/WindowManager/qmldir (+2/-0) qml/Components/KeymapSwitcher.qml (+1/-9) qml/Greeter/Greeter.qml (+5/-4) qml/Launcher/LauncherPanel.qml (+1/-0) qml/Shell.qml (+67/-53) qml/Stages/AbstractStage.qml (+9/-2) qml/Stages/Animations/BaseSessionAnimation.qml (+0/-96) qml/Stages/Animations/SwipeFromBottomAnimation.qml (+0/-53) qml/Stages/ApplicationWindow.qml (+110/-68) qml/Stages/DecoratedWindow.qml (+5/-5) qml/Stages/DesktopSpread.qml (+22/-18) qml/Stages/DesktopSpreadDelegate.qml (+4/-3) qml/Stages/DesktopStage.qml (+162/-101) qml/Stages/PhoneStage.qml (+154/-91) qml/Stages/PromptSurfaceAnimations.qml (+81/-0) qml/Stages/SpreadDelegate.qml (+4/-3) qml/Stages/StagedFullscreenPolicy.qml (+12/-14) qml/Stages/SurfaceContainer.qml (+0/-154) qml/Stages/TabletStage.qml (+312/-249) qml/Stages/TopLevelSurfaceRepeater.qml (+52/-0) qml/Stages/TransformedSpreadDelegate.qml (+4/-4) qml/Stages/TransformedTabletSpreadDelegate.qml (+29/-23) qml/Stages/WindowedFullscreenPolicy.qml (+5/-7) qml/Tutorial/TutorialBottom.qml (+1/-1) tests/mocks/Unity/Application/ApplicationInfo.cpp (+195/-122) tests/mocks/Unity/Application/ApplicationInfo.h (+39/-24) tests/mocks/Unity/Application/ApplicationManager.cpp (+115/-80) tests/mocks/Unity/Application/ApplicationManager.h (+12/-14) tests/mocks/Unity/Application/ApplicationTestInterface.cpp (+0/-117) tests/mocks/Unity/Application/ApplicationTestInterface.h (+0/-45) tests/mocks/Unity/Application/CMakeLists.txt (+3/-4) tests/mocks/Unity/Application/MirSurface.cpp (+175/-10) tests/mocks/Unity/Application/MirSurface.h (+51/-7) tests/mocks/Unity/Application/MirSurfaceItem.cpp (+13/-7) tests/mocks/Unity/Application/MirSurfaceListModel.cpp (+121/-0) tests/mocks/Unity/Application/MirSurfaceListModel.h (+56/-0) tests/mocks/Unity/Application/ObjectListModel.h (+2/-0) tests/mocks/Unity/Application/Session.cpp (+0/-209) tests/mocks/Unity/Application/Session.h (+0/-104) tests/mocks/Unity/Application/SessionManager.cpp (+0/-55) tests/mocks/Unity/Application/SessionManager.h (+0/-44) tests/mocks/Unity/Application/SessionModel.h (+0/-35) tests/mocks/Unity/Application/SurfaceManager.cpp (+16/-9) tests/mocks/Unity/Application/SurfaceManager.h (+5/-2) tests/mocks/Unity/Application/UbuntuKeyboardInfo.cpp (+0/-2) tests/mocks/Unity/Application/UbuntuKeyboardInfo.h (+0/-9) tests/mocks/Unity/Application/VirtualKeyboard.cpp (+2/-3) tests/mocks/Unity/Application/VirtualKeyboard.h (+1/-1) tests/mocks/Unity/Application/plugin.cpp (+41/-44) tests/mocks/Utils/CMakeLists.txt (+4/-0) tests/mocks/Utils/plugin.cpp (+1/-1) tests/plugins/Unity/Launcher/launchermodeltest.cpp (+2/-3) tests/qmltests/CMakeLists.txt (+0/-1) tests/qmltests/Dash/tst_DashShell.qml (+6/-2) tests/qmltests/Greeter/tst_Greeter.qml (+2/-2) tests/qmltests/Panel/tst_ActiveCallHint.qml (+3/-2) tests/qmltests/Panel/tst_Panel.qml (+2/-2) tests/qmltests/Stages/ApplicationCheckBox.qml (+117/-71) tests/qmltests/Stages/RecursingChildSessionControl.qml (+10/-61) tests/qmltests/Stages/tst_ApplicationWindow.qml (+84/-70) tests/qmltests/Stages/tst_DesktopStage.qml (+253/-171) tests/qmltests/Stages/tst_PhoneStage.qml (+272/-82) tests/qmltests/Stages/tst_SpreadDelegate.qml (+3/-2) tests/qmltests/Stages/tst_SurfaceContainer.qml (+0/-184) tests/qmltests/Stages/tst_TabletStage.qml (+255/-92) tests/qmltests/Tutorial/tst_Tutorial.qml (+4/-8) tests/qmltests/tst_OrientedShell.qml (+96/-69) tests/qmltests/tst_Shell.qml (+244/-171) tests/qmltests/tst_ShellWithPin.qml (+9/-13) tests/utils/modules/Unity/Test/UnityTestCase.qml (+20/-2)
To merge this branch:	bzr merge lp:~dandrader/unity8/surfaceListModel
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Michał Sawicz			Approve on 2016-04-22
Unity8 CI Bot	continuous-integration	2016-03-29	Needs Fixing on 2016-04-20
Lukáš Tinkl (community)			Approve on 2016-04-15
Gerry Boland (community)		2016-03-29	Approve on 2016-04-11
Nick Dedekind (community)			Needs Fixing on 2016-03-30
Review via email: mp+290314@code.launchpad.net

Commit message

Surface-based window management

- We no longer deal with the Session concept.
- Each application has a list of top-level surfaces and each surface has a list of prompt surfaces (general support for child surfaces not yet implemented)
- Stages (desktop, phone and tablet) work on a TopLevelSurfaceList model instead of ApplicationManager.
- TopLevelSurfaceList contains all the top-level surfaces from all running (or suspended) applications

Description of the change

* Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~dandrader/unity-api/surfaceListModel/+merge/290315
https://code.launchpad.net/~dandrader/qtmir/surfaceListModel/+merge/290316

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

For testing the "multiple surfaces per application" feature you can use multiwindow.qml from lp:~dandrader/+junk/animatedDemos

You can also create as many surfaces for an application as you want in qml tests UI controls, like in "make tryShell"

* 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?
N/A

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

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-29:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/881/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-29:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/883/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-03-30:

UI bug:
1. open dialer app
2. hit power key to display off, then again to display on
3. enter PIN
4. watch the dialer-app surface

I see dialer-app surface resize after you unlock. AS if it switches from fullscreen back to windowed.

review: Needs Fixing

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-03-30:

Camera app not becoming fullscreen in 2 ways for me (Nexus 4):
1. panel still visible
2. camera view not filling the whole of the app surface.
See http://imgur.com/GCj7O4R

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-03-30:

On phone, I'm not seeing background apps being suspended at all!

Wakelocks are being managed ok though, afaics.

review: Needs Fixing

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-03-30:

Gallery unable to make images fullscreen when viewing them.

Also confirmed that apps not being suspended (they are getting the expose events though) - start Dropping letters and then switch away - game will not stop and you will loose

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-03-30:

OOM killing not behaving as I'd expect.
1. I managed to crash unity8 with 4 apps open, and killing a non-visible one via command line. Not easily reproduced though
2. Open dialer & clock. Let both load. Focus dialer. Then kill the clock process via adb. Opening spread, the Clock app has been removed from the list. It should remain, and relaunch the app if focused.
3. Open clock. Switch back to Dash. Kill the clock process. Then tap the Clock app in the dash to re-launch it. No splash appears, but clock does appear a moment later.

review: Needs Fixing

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2016-03-30:

A few code comments attached.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-03-30:

On 30/03/2016 13:16, Nick Dedekind wrote:
> Why slots rather than invokables?

Because that's the new way for expressing functions callable from QML it
seems. At least mzanetti told me to do like that.

I do see the benefit of cleaner looking header files at least...

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2016-03-30:

Getting an animation artifact in tablet stage. Not sure if it's in trunk, but I think you reported something similar and I fixed it.

TestCase:
Open a bunch of apps, swipe in switcher.
Select an app ( not bottom ).

Expected:
App expands to full screen with apps behind not visible.

Actual:
Briefly see the app behind it until selected one becomes opaque.

review: Needs Fixing

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2016-03-30:

Tablet (N7) just rebooted... power button + greeter swipe a few times.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-03-30:

On 30/03/2016 13:16, Nick Dedekind wrote:
> why not just use INT_MAX to decrease your duplicate hit?

Gerry made the same question. Short answer is:
Code does m_maxId+1. If m_maxId is indeed the absolut maximum the
variable type can handle it will overflow and be -INT_MAX (negative).

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2016-03-30:

Tablet Stage:
Side stage becomes immediately visible when swiping for spread.

Test:
Open app.
Send to side stage.
Close side stage.
Slowly swipe in spread

Expected:
Side stage swipes in with finger movement.
Can reverse direction

Actual:
Side stage becomes immediately visible.

review: Needs Fixing

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-30:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/898/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-03-31:

"""
Played with this over the weekend on my Bq. Issues found:
1. app start animation broken, splash doesn't slide in, it just appears
2. left edge swipe broken, it always bounces back. Can never get to Dash using that method.
3. launcher not launching apps
4. launcher not switching apps
5. app focus has changed slightly, there are times with OSK stays visible, when it should have gone away. Examples:
  i. have app with OSK up, open indicators. OSK remains up.
  ii. have app with OSK up, right-edge swipe to bring up spread. OSK remains up
6. not moving focus to trust prompt sessions. Example, in Camera app, try share photo:
   i. share selector surface not animated in from bottom
   ii. selected share app not brought to front.
"""

Fixed all items.

6.i is wrong though: that share selector seems to be inside camera's surface since I don't see any notice of new surface coming up, trusted session or anything of the like in qtmir's log.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-31:

FAILED: Continuous integration, rev:2313
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/909/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1221/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/909/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-03-31:

On 30/03/2016 11:07, Gerry Boland wrote:
> Review: Needs Fixing
>
> UI bug:
> 1. open dialer app
> 2. hit power key to display off, then again to display on
> 3. enter PIN
> 4. watch the dialer-app surface
>
> I see dialer-app surface resize after you unlock. AS if it switches from fullscreen back to windowed.

Can't reproduce it. Might have been fixed as well along with the other
issues.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-03-31:

On 30/03/2016 11:13, Gerry Boland wrote:
> Camera app not becoming fullscreen in 2 ways for me (Nexus 4):
> 1. panel still visible
> 2. camera view not filling the whole of the app surface.
> See http://imgur.com/GCj7O4R

Fixed.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-03-31:

FAILED: Continuous integration, rev:2314
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/910/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1227/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/910/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 11:21, Gerry Boland wrote:
> Review: Needs Fixing
>
> On phone, I'm not seeing background apps being suspended at all!
>
> Wakelocks are being managed ok though, afaics.

Fixed.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-01:

FAILED: Continuous integration, rev:2315
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/914/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1240/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/914/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 11:30, Gerry Boland wrote:
> Gallery unable to make images fullscreen when viewing them.

Already fixed

> Also confirmed that apps not being suspended (they are getting the expose events though) - start Dropping letters and then switch away - game will not stop and you will loose

Already fixed

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 12:10, Gerry Boland wrote:
> Review: Needs Fixing
>
> OOM killing not behaving as I'd expect.
> 1. I managed to crash unity8 with 4 apps open, and killing a non-visible one via command line. Not easily reproduced though

Stacktrace please. And try again since a lot has changed since then

> 2. Open dialer & clock. Let both load. Focus dialer. Then kill the clock process via adb. Opening spread, the Clock app has been removed from the list. It should remain, and relaunch the app if focused.

Already fixed.

> 3. Open clock. Switch back to Dash. Kill the clock process. Then tap the Clock app in the dash to re-launch it. No splash appears, but clock does appear a moment later.
>

Fixed.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-01:

FAILED: Continuous integration, rev:2316
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/916/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1244/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/916/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 13:39, Nick Dedekind wrote:
> Review: Needs Fixing
>
> Tablet Stage:
> Side stage becomes immediately visible when swiping for spread.
>
> Test:
> Open app.
> Send to side stage.
> Close side stage.
> Slowly swipe in spread
>
> Expected:
> Side stage swipes in with finger movement.
> Can reverse direction
>
> Actual:
> Side stage becomes immediately visible.

Fixed.

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 13:27, Nick Dedekind wrote:
> Review: Needs Fixing
>
> Getting an animation artifact in tablet stage. Not sure if it's in trunk, but I think you reported something similar and I fixed it.
>
> TestCase:
> Open a bunch of apps, swipe in switcher.
> Select an app ( not bottom ).
>
> Expected:
> App expands to full screen with apps behind not visible.
>
> Actual:
> Briefly see the app behind it until selected one becomes opaque.
>

Didn't get the "not bottom" comment.

Anyway, tried with "make tryTabletStage" by clicking on all app
checkboxes, going to spread, and selecting the left most or middle
window. Didn't spot a difference in behaviour between trunk and this branch.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-01:

FAILED: Continuous integration, rev:2317
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/919/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1247/console

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/919/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-01:

On 30/03/2016 13:29, Nick Dedekind wrote:
> Tablet (N7) just rebooted... power button + greeter swipe a few times.

Can't reproduce.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-04:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/926/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-05:

You've done some good work, phone is behaving much better now!

Some issues I've found while testing. Nothing in any specific order:
1. open 2 apps. Open the spread. Then reveal launcher and start a *new* app. I see spread closing, with focus going to the last focused app. The new app does launch, but in the background.
2. I've noticed that when an application starts & is shown on screen, it's Qt.application.active is not set to true. If I open spread & reselect it, then Qt.app.active becomes true. This will break camera app.

review: Needs Fixing

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/930/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-05:

On 05/04/2016 08:13, Gerry Boland wrote:
> Review: Needs Fixing
>
> You've done some good work, phone is behaving much better now!
>
> Some issues I've found while testing. Nothing in any specific order:
> 1. open 2 apps. Open the spread. Then reveal launcher and start a *new* app. I see spread closing, with focus going to the last focused app. The new app does launch, but in the background.

Fixed

> 2. I've noticed that when an application starts & is shown on screen, it's Qt.application.active is not set to true. If I open spread & reselect it, then Qt.app.active becomes true. This will break camera app.

Fixed.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/931/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/932/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/933/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/935/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-06:

Was this an existing bug on the Tablet?:
Open these apps & orient them in the Spread in this order:
1. Dialer app - side stage
2. Dash
3. Messaging app - main stage
with Dialer on top, Messaging on bottom of the stack.

Open spread, try to tap the Dash surface - but only tap to the right of the Messaging app (i.e. the smaller bit of the Dash surface exposed), to select it. See https://imgur.com/vVnthDu

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-06:

Just testing N7 with mouse connected (desktop mode) - the mouse cursor is not visible

review: Needs Fixing

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-06:

Aha, not accurate. It appears mouse does not draw itself until it moves at least once!

Desktop mode testing:
1. Open System Settings. With indicators are open on Time & date page, tap the "Time & Date settings" entry. For me, the indicator stays open, but System Settings does change to the correct page in the background. The indicator should close.

2. In the desktop spread, System Settings has a preview, an icon, but is missing its text. This might not be new though.

I've tested some basic multi-window apps. You have things working nicely.

review: Needs Fixing

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-06:

On 06/04/2016 08:08, Gerry Boland wrote:
> Was this an existing bug on the Tablet?:
> Open these apps & orient them in the Spread in this order:
> 1. Dialer app - side stage
> 2. Dash
> 3. Messaging app - main stage
> with Dialer on top, Messaging on bottom of the stack.
>
> Open spread, try to tap the Dash surface - but only tap to the right of the Messaging app (i.e. the smaller bit of the Dash surface exposed), to select it. See https://imgur.com/vVnthDu

Nothing happens when I tap on the red "X" location on trunk. So,
pre-existing behavior

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-06:

On 06/04/2016 08:28, Gerry Boland wrote:
> Desktop mode testing:
> 1. Open System Settings. With indicators are open on Time & date page, tap the "Time & Date settings" entry. For me, the indicator stays open, but System Settings does change to the correct page in the background. The indicator should close.

Fixed.

>
> 2. In the desktop spread, System Settings has a preview, an icon, but is missing its text. This might not be new though.
>

Fixed.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-06:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/941/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-06:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/942/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-06:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/944/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-06:

Run unity8 autopilot tests and got only one failure, which is the same result I got with trunk.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/953/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/954/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/955/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/956/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/957/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-07:

All tests should be passing now.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/958/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/959/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-08:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/964/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-08:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/965/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-11:

Did last round of AP tests, unity8 tests ok, UITK tests have similar number of fails before & after. Bunch more manual testing not revealed anything. Overall, I think this is good to go! Nice work

review: Approve

Revision history for this message

Gerry Boland (gerboland) wrote on 2016-04-11:

OFC need to sort out dependencies

Revision history for this message

Lukáš Tinkl (lukas-kde) wrote on 2016-04-12:

readonly property string title: surface && surface.name !== "" ? surface.name + " - " + d.name : d.name

This leads to funny window titles like "Scopes - Scopes"

review: Needs Fixing

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-12:

On 12/04/2016 12:11, Lukáš Tinkl wrote:
> Review: Needs Fixing
>
> readonly property string title: surface && surface.name !== "" ? surface.name + " - " + d.name : d.name
>
> This leads to funny window titles like "Scopes - Scopes"

Fixed.

Revision history for this message

Lukáš Tinkl (lukas-kde) wrote on 2016-04-12:

OK, wfm

review: Abstain

Revision history for this message

Lukáš Tinkl (lukas-kde) wrote on 2016-04-13:

- onFocusMaximizedApp: if (priv.foregroundMaximizedAppIndex != -1) {
- ApplicationManager.focusApplication(appRepeater.itemAt(priv.foregroundMaximizedAppIndex).appId);
- }

^^ this piece of code disappeared without replacement from DesktopStage.qml; now it's no longer possible to focus a maximized app in the background by clicking the panel.

review: Needs Fixing

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2016-04-13:

On 13/04/2016 05:59, Lukáš Tinkl wrote:
> Review: Needs Fixing
>
> - onFocusMaximizedApp: if (priv.foregroundMaximizedAppIndex != -1) {
> - ApplicationManager.focusApplication(appRepeater.itemAt(priv.foregroundMaximizedAppIndex).appId);
> - }
>
>
> ^^ this piece of code disappeared without replacement from DesktopStage.qml; now it's no longer possible to focus a maximized app in the background by clicking the panel.

Fixed.

Revision history for this message

Lukáš Tinkl (lukas-kde) wrote on 2016-04-15:

OK, no more issues spotted

review: Approve

Revision history for this message

Michał Sawicz (saviq) wrote on 2016-04-20:

- // Emit signal to notify Upstart that Mir is ready to receive client connections
- // see http://upstart.ubuntu.com/cookbook/#expect-stop
- if (qgetenv("UNITY_MIR_EMITS_SIGSTOP") == "1") {
- raise(SIGSTOP);
- }

That's no good - autopilot tests hang because of this.

review: Needs Fixing

lp:~dandrader/unity8/surfaceListModel updated on 2016-04-20

2359. By Daniel d'Andrada on 2016-04-20: Bring back raise(SIGSTOP) to our ApplicationManager mock
2360. By Daniel d'Andrada on 2016-04-20: Fix typo in comment

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-20:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1032/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-04-20:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1033/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Michał Sawicz (saviq) on 2016-04-22:

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mohammad Rakibul Hasan

Unity Team

 === modified file 'debian/control'
 --- debian/control	2016-04-20 17:09:15 +0000
 +++ debian/control	2016-04-20 17:09:16 +0000
@@ -30,7 +30,7 @@
                 libqt5xmlpatterns5-dev,
                 libsystemsettings-dev,
                 libudev-dev,
--               libunity-api-dev (>= 7.108),
++               libunity-api-dev (>= 7.110),
                 libusermetricsoutput1-dev,
  # Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop
                 libx11-dev[!armhf],
 === modified file 'debian/unity8-private.install'
 --- debian/unity8-private.install	2015-11-18 09:15:06 +0000
 +++ debian/unity8-private.install	2016-04-20 17:09:16 +0000
@@ -14,6 +14,7 @@
  usr/lib/*/unity8/qml/Unity
  usr/lib/*/unity8/qml/UInput
  usr/lib/*/unity8/qml/Utils
++usr/lib/*/unity8/qml/WindowManager
  usr/lib/*/unity8/qml/Wizard
  usr/share/accountsservice/interfaces
  usr/share/dbus-1/interfaces
 === modified file 'plugins/CMakeLists.txt'
 --- plugins/CMakeLists.txt	2015-11-11 16:03:24 +0000
 +++ plugins/CMakeLists.txt	2016-04-20 17:09:16 +0000
@@ -25,4 +25,5 @@
  add_subdirectory(UInput)
  add_subdirectory(Unity)
  add_subdirectory(Utils)
++add_subdirectory(WindowManager)
  add_subdirectory(Wizard)
 === added directory 'plugins/WindowManager'
 === added file 'plugins/WindowManager/CMakeLists.txt'
 --- plugins/WindowManager/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/CMakeLists.txt	2016-04-20 17:09:16 +0000
@@ -0,0 +1,13 @@
++set(WINDOWMANAGER_SRC
++    TopLevelSurfaceList.cpp
++    WindowManagerPlugin.cpp
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
++   )
++
++add_library(windowmanager-qml SHARED ${WINDOWMANAGER_SRC})
++
++qt5_use_modules(windowmanager-qml Qml Quick Gui)
++
++add_unity8_plugin(WindowManager 0.1 WindowManager TARGETS windowmanager-qml)
 === added file 'plugins/WindowManager/TopLevelSurfaceList.cpp'
 --- plugins/WindowManager/TopLevelSurfaceList.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/TopLevelSurfaceList.cpp	2016-04-20 17:09:16 +0000
@@ -0,0 +1,486 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "TopLevelSurfaceList.h"
++
++// unity-api
++#include <unity/shell/application/ApplicationInfoInterface.h>
++#include <unity/shell/application/MirSurfaceInterface.h>
++#include <unity/shell/application/MirSurfaceListInterface.h>
++
++#include <QMetaObject>
++
++Q_LOGGING_CATEGORY(UNITY_TOPSURFACELIST, "unity.topsurfacelist", QtDebugMsg)
++
++#define DEBUG_MSG qCDebug(UNITY_TOPSURFACELIST).nospace().noquote() << __func__
++
++using namespace unity::shell::application;
++
++TopLevelSurfaceList::TopLevelSurfaceList(QObject *parent) :
++    QAbstractListModel(parent)
++{
++    DEBUG_MSG << "()";
++}
++
++TopLevelSurfaceList::~TopLevelSurfaceList()
++{
++    DEBUG_MSG << "()";
++}
++
++int TopLevelSurfaceList::rowCount(const QModelIndex &parent) const
++{
++    return !parent.isValid() ? m_surfaceList.size() : 0;
++}
++
++QVariant TopLevelSurfaceList::data(const QModelIndex& index, int role) const
++{
++    if (index.row() < 0 || index.row() >= m_surfaceList.size())
++        return QVariant();
++
++    if (role == SurfaceRole) {
++        MirSurfaceInterface *surface = m_surfaceList.at(index.row()).surface;
++        return QVariant::fromValue(surface);
++    } else if (role == ApplicationRole) {
++        return QVariant::fromValue(m_surfaceList.at(index.row()).application);
++    } else if (role == IdRole) {
++        return QVariant::fromValue(m_surfaceList.at(index.row()).id);
++    } else {
++        return QVariant();
++    }
++}
++
++void TopLevelSurfaceList::raise(MirSurfaceInterface *surface)
++{
++    if (!surface)
++        return;
++
++    DEBUG_MSG << "(MirSurface[" << (void*)surface << "])";
++
++    int i = indexOf(surface);
++    if (i != -1) {
++        raiseId(m_surfaceList.at(i).id);
++    }
++}
++
++void TopLevelSurfaceList::appendPlaceholder(ApplicationInfoInterface *application)
++{
++    DEBUG_MSG << "(" << application->appId() << ")";
++
++    appendSurfaceHelper(nullptr, application);
++}
++
++void TopLevelSurfaceList::appendSurface(MirSurfaceInterface *surface, ApplicationInfoInterface *application)
++{
++    Q_ASSERT(surface != nullptr);
++
++    bool filledPlaceholder = false;
++    for (int i = 0; i < m_surfaceList.count() && !filledPlaceholder; ++i) {
++        ModelEntry &entry = m_surfaceList[i];
++        if (entry.application == application && entry.surface == nullptr) {
++            entry.surface = surface;
++            connectSurface(surface);
++            DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface
++                      << ", filling out placeholder. after: " << toString();
++            Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);
++            filledPlaceholder = true;
++        }
++    }
++
++    if (!filledPlaceholder) {
++        DEBUG_MSG << " appId=" << application->appId() << " surface=" << surface << ", adding new row";
++        appendSurfaceHelper(surface, application);
++    }
++}
++
++void TopLevelSurfaceList::appendSurfaceHelper(MirSurfaceInterface *surface, ApplicationInfoInterface *application)
++{
++    if (m_modelState == IdleState) {
++        m_modelState = InsertingState;
++        beginInsertRows(QModelIndex(), m_surfaceList.size() /*first*/, m_surfaceList.size() /*last*/);
++    } else {
++        Q_ASSERT(m_modelState == ResettingState);
++        // No point in signaling anything if we're resetting the whole model
++    }
++
++    int id = generateId();
++    m_surfaceList.append(ModelEntry(surface, application, id));
++    if (surface) {
++        connectSurface(surface);
++    }
++
++    if (m_modelState == InsertingState) {
++        endInsertRows();
++        Q_EMIT countChanged();
++        Q_EMIT listChanged();
++        m_modelState = IdleState;
++    }
++
++    DEBUG_MSG << " after " << toString();
++}
++
++void TopLevelSurfaceList::connectSurface(MirSurfaceInterface *surface)
++{
++    connect(surface, &MirSurfaceInterface::focusedChanged, this, [this, surface](bool focused){
++            if (focused) {
++                this->raise(surface);
++            }
++        });
++    connect(surface, &MirSurfaceInterface::liveChanged, this, [this, surface](bool live){
++            if (!live) {
++                onSurfaceDied(surface);
++            }
++        });
++    connect(surface, &QObject::destroyed, this, [this, surface](){ this->onSurfaceDestroyed(surface); });
++}
++
++void TopLevelSurfaceList::onSurfaceDied(MirSurfaceInterface *surface)
++{
++    int i = indexOf(surface);
++    if (i == -1) {
++        return;
++    }
++
++    auto application = m_surfaceList[i].application;
++
++    // can't be starting if it already has a surface
++    Q_ASSERT(application->state() != ApplicationInfoInterface::Starting);
++
++    if (application->state() == ApplicationInfoInterface::Running) {
++        m_surfaceList[i].removeOnceSurfaceDestroyed = true;
++    } else {
++        // assume it got killed by the out-of-memory daemon.
++        //
++        // So leave entry in the model and only remove its surface, so shell can display a screenshot
++        // in its place.
++        m_surfaceList[i].removeOnceSurfaceDestroyed = false;
++    }
++}
++
++void TopLevelSurfaceList::onSurfaceDestroyed(MirSurfaceInterface *surface)
++{
++    int i = indexOf(surface);
++    if (i == -1) {
++        return;
++    }
++
++    if (m_surfaceList[i].removeOnceSurfaceDestroyed) {
++        removeAt(i);
++    } else {
++        m_surfaceList[i].surface = nullptr;
++        Q_EMIT dataChanged(index(i) /* topLeft */, index(i) /* bottomRight */, QVector<int>() << SurfaceRole);
++        DEBUG_MSG << " Removed surface from entry. After: " << toString();
++    }
++}
++
++void TopLevelSurfaceList::removeAt(int index)
++{
++    if (m_modelState == IdleState) {
++        beginRemoveRows(QModelIndex(), index, index);
++        m_modelState = RemovingState;
++    } else {
++        Q_ASSERT(m_modelState == ResettingState);
++        // No point in signaling anything if we're resetting the whole model
++    }
++
++    m_surfaceList.removeAt(index);
++
++    if (m_modelState == RemovingState) {
++        endRemoveRows();
++        Q_EMIT countChanged();
++        Q_EMIT listChanged();
++        m_modelState = IdleState;
++    }
++
++    DEBUG_MSG << " after " << toString();
++}
++
++int TopLevelSurfaceList::indexOf(MirSurfaceInterface *surface)
++{
++    for (int i = 0; i < m_surfaceList.count(); ++i) {
++        if (m_surfaceList.at(i).surface == surface) {
++            return i;
++        }
++    }
++    return -1;
++}
++
++void TopLevelSurfaceList::move(int from, int to)
++{
++    if (from == to) return;
++    DEBUG_MSG << " from=" << from << " to=" << to;
++
++    if (from >= 0 && from < m_surfaceList.size() && to >= 0 && to < m_surfaceList.size()) {
++        QModelIndex parent;
++        /* When moving an item down, the destination index needs to be incremented
++           by one, as explained in the documentation:
++           http://qt-project.org/doc/qt-5.0/qtcore/qabstractitemmodel.html#beginMoveRows */
++
++        Q_ASSERT(m_modelState == IdleState);
++        m_modelState = MovingState;
++
++        beginMoveRows(parent, from, from, parent, to + (to > from ? 1 : 0));
++        m_surfaceList.move(from, to);
++        endMoveRows();
++        Q_EMIT listChanged();
++
++        m_modelState = IdleState;
++
++        DEBUG_MSG << " after " << toString();
++    }
++}
++
++MirSurfaceInterface *TopLevelSurfaceList::surfaceAt(int index) const
++{
++    if (index >=0 && index < m_surfaceList.count()) {
++        return m_surfaceList[index].surface;
++    } else {
++        return nullptr;
++    }
++}
++
++ApplicationInfoInterface *TopLevelSurfaceList::applicationAt(int index) const
++{
++    if (index >=0 && index < m_surfaceList.count()) {
++        return m_surfaceList[index].application;
++    } else {
++        return nullptr;
++    }
++}
++
++int TopLevelSurfaceList::idAt(int index) const
++{
++    if (index >=0 && index < m_surfaceList.count()) {
++        return m_surfaceList[index].id;
++    } else {
++        return 0;
++    }
++}
++
++int TopLevelSurfaceList::indexForId(int id) const
++{
++    for (int i = 0; i < m_surfaceList.count(); ++i) {
++        if (m_surfaceList[i].id == id) {
++            return i;
++        }
++    }
++    return -1;
++}
++
++void TopLevelSurfaceList::doRaiseId(int id)
++{
++    int fromIndex = indexForId(id);
++    if (fromIndex != -1) {
++        move(fromIndex, 0 /* toIndex */);
++    }
++}
++
++void TopLevelSurfaceList::raiseId(int id)
++{
++    if (m_modelState == IdleState) {
++        DEBUG_MSG << "(id=" << id << ") - do it now.";
++        doRaiseId(id);
++    } else {
++        DEBUG_MSG << "(id=" << id << ") - Model busy (modelState=" << m_modelState << "). Try again in the next event loop.";
++        // The model has just signalled some change. If we have a Repeater responding to this update, it will get nuts
++        // if we perform yet another model change straight away.
++        //
++        // A bad sympton of this problem is a Repeater.itemAt(index) call returning null event though Repeater.count says
++        // the index is definitely within bounds.
++        QMetaObject::invokeMethod(this, "raiseId", Qt::QueuedConnection, Q_ARG(int, id));
++    }
++}
++
++int TopLevelSurfaceList::generateId()
++{
++    int id = m_nextId;
++    m_nextId = nextFreeId(m_nextId + 1);
++    Q_EMIT nextIdChanged();
++    return id;
++}
++
++int TopLevelSurfaceList::nextFreeId(int candidateId)
++{
++    if (candidateId > m_maxId) {
++        return nextFreeId(1);
++    } else {
++        if (indexForId(candidateId) == -1) {
++            // it's indeed free
++            return candidateId;
++        } else {
++            return nextFreeId(candidateId + 1);
++        }
++    }
++}
++
++QString TopLevelSurfaceList::toString()
++{
++    QString str;
++    for (int i = 0; i < m_surfaceList.count(); ++i) {
++        auto item = m_surfaceList.at(i);
++
++        QString itemStr = QString("(index=%1,appId=%2,surface=0x%3,id=%4)")
++            .arg(i)
++            .arg(item.application->appId())
++            .arg((qintptr)item.surface, 0, 16)
++            .arg(item.id);
++
++        if (i > 0) {
++            str.append(",");
++        }
++        str.append(itemStr);
++    }
++    return str;
++}
++
++void TopLevelSurfaceList::addApplication(ApplicationInfoInterface *application)
++{
++    DEBUG_MSG << "(" << application->appId() << ")";
++    Q_ASSERT(!m_applications.contains(application));
++    m_applications.append(application);
++
++    MirSurfaceListInterface *surfaceList = application->surfaceList();
++
++    if (application->state() != ApplicationInfoInterface::Stopped) {
++        if (surfaceList->count() == 0) {
++            appendPlaceholder(application);
++        } else {
++            for (int i = 0; i < surfaceList->count(); ++i) {
++                appendSurface(surfaceList->get(i), application);
++            }
++        }
++    }
++
++    connect(surfaceList, &QAbstractItemModel::rowsInserted, this,
++            [this, application, surfaceList](const QModelIndex & /*parent*/, int first, int last)
++            {
++                for (int i = last; i >= first; --i) {
++                    this->appendSurface(surfaceList->get(i), application);
++                }
++            });
++}
++
++void TopLevelSurfaceList::removeApplication(ApplicationInfoInterface *application)
++{
++    DEBUG_MSG << "(" << application->appId() << ")";
++    Q_ASSERT(m_applications.contains(application));
++
++    MirSurfaceListInterface *surfaceList = application->surfaceList();
++
++    disconnect(surfaceList, 0, this, 0);
++
++    Q_ASSERT(m_modelState == IdleState);
++    m_modelState = RemovingState;
++
++    int i = 0;
++    while (i < m_surfaceList.count()) {
++        if (m_surfaceList.at(i).application == application) {
++            beginRemoveRows(QModelIndex(), i, i);
++            m_surfaceList.removeAt(i);
++            endRemoveRows();
++            Q_EMIT countChanged();
++            Q_EMIT listChanged();
++        } else {
++            ++i;
++        }
++    }
++
++    m_modelState = IdleState;
++
++    DEBUG_MSG << " after " << toString();
++
++    m_applications.removeAll(application);
++}
++
++QAbstractListModel *TopLevelSurfaceList::applicationsModel() const
++{
++    return m_applicationsModel;
++}
++
++void TopLevelSurfaceList::setApplicationsModel(QAbstractListModel* value)
++{
++    if (m_applicationsModel == value) {
++        return;
++    }
++
++    DEBUG_MSG << "(" << value << ")";
++
++    Q_ASSERT(m_modelState == IdleState);
++    m_modelState = ResettingState;
++
++    beginResetModel();
++
++    if (m_applicationsModel) {
++        m_surfaceList.clear();
++        m_applications.clear();
++        disconnect(m_applicationsModel, 0, this, 0);
++    }
++
++    m_applicationsModel = value;
++
++    if (m_applicationsModel) {
++        findApplicationRole();
++
++        connect(m_applicationsModel, &QAbstractItemModel::rowsInserted,
++                this, [this](const QModelIndex &/*parent*/, int first, int last) {
++                    for (int i = first; i <= last; ++i) {
++                        auto application = getApplicationFromModelAt(i);
++                        addApplication(application);
++                    }
++                });
++
++        connect(m_applicationsModel, &QAbstractItemModel::rowsAboutToBeRemoved,
++                this, [this](const QModelIndex &/*parent*/, int first, int last) {
++                    for (int i = first; i <= last; ++i) {
++                        auto application = getApplicationFromModelAt(i);
++                        removeApplication(application);
++                    }
++                });
++
++        for (int i = 0; i < m_applicationsModel->rowCount(); ++i) {
++            auto application = getApplicationFromModelAt(i);
++            addApplication(application);
++        }
++    }
++
++    endResetModel();
++    m_modelState = IdleState;
++}
++
++ApplicationInfoInterface *TopLevelSurfaceList::getApplicationFromModelAt(int index)
++{
++    QModelIndex modelIndex = m_applicationsModel->index(index);
++
++    QVariant variant =  m_applicationsModel->data(modelIndex, m_applicationRole);
++
++    // variant.value<ApplicationInfoInterface*>() returns null for some reason.
++    return static_cast<ApplicationInfoInterface*>(variant.value<QObject*>());
++}
++
++void TopLevelSurfaceList::findApplicationRole()
++{
++    QHash<int, QByteArray> namesHash = m_applicationsModel->roleNames();
++
++    m_applicationRole = -1;
++    for (auto i = namesHash.begin(); i != namesHash.end() && m_applicationRole == -1; ++i) {
++        if (i.value() == "application") {
++            m_applicationRole = i.key();
++        }
++    }
++
++    if (m_applicationRole == -1) {
++        qFatal("TopLevelSurfaceList: applicationsModel must have a \"application\" role.");
++    }
++}
 === added file 'plugins/WindowManager/TopLevelSurfaceList.h'
 --- plugins/WindowManager/TopLevelSurfaceList.h	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/TopLevelSurfaceList.h	2016-04-20 17:09:16 +0000
@@ -0,0 +1,223 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef TOPLEVELSURFACELIST_H
++#define TOPLEVELSURFACELIST_H
++
++#include <QAbstractListModel>
++#include <QList>
++#include <QLoggingCategory>
++
++Q_DECLARE_LOGGING_CATEGORY(UNITY_TOPSURFACELIST)
++
++namespace unity {
++    namespace shell {
++        namespace application {
++            class ApplicationInfoInterface;
++            class MirSurfaceInterface;
++        }
++    }
++}
++
++/**
++ * @brief A model of top-level surfaces
++ *
++ * It's an abstraction of top-level application windows.
++ *
++ * When an entry first appears, it normaly doesn't have a surface yet, meaning that the application is
++ * still starting up. A shell should then display a splash screen or saved screenshot of the application
++ * until its surface comes up.
++ *
++ * As applications can have multiple surfaces and you can also have entries without surfaces at all,
++ * the only way to unambiguously refer to an entry in this model is through its id.
++ */
++class TopLevelSurfaceList : public QAbstractListModel
++{
++
++    Q_OBJECT
++
++    /**
++     * @brief A list model of applications.
++     *
++     * It's expected to have a role called "application" which returns a ApplicationInfoInterface
++     */
++    Q_PROPERTY(QAbstractListModel* applicationsModel READ applicationsModel
++                                                     WRITE setApplicationsModel
++                                                     NOTIFY applicationsModelChanged)
++
++    /**
++     * @brief Number of top-level surfaces in this model
++     *
++     * This is the same as rowCount, added in order to keep compatibility with QML ListModels.
++     */
++    Q_PROPERTY(int count READ rowCount NOTIFY countChanged)
++
++    /**
++      The id to be used on the next entry created
++      Useful for tests
++     */
++    Q_PROPERTY(int nextId READ nextId NOTIFY nextIdChanged)
++public:
++
++    /**
++     * @brief The Roles supported by the model
++     *
++     * SurfaceRole - A MirSurfaceInterface. It will be null if the application is still starting up
++     * ApplicationRole - An ApplicationInfoInterface
++     * IdRole - A unique identifier for this entry. Useful to unambiguosly track elements as they move around in the list
++     */
++    enum Roles {
++        SurfaceRole = Qt::UserRole,
++        ApplicationRole = Qt::UserRole + 1,
++        IdRole = Qt::UserRole + 2,
++    };
++
++    explicit TopLevelSurfaceList(QObject *parent = nullptr);
++    virtual ~TopLevelSurfaceList();
++
++    // QAbstractItemModel methods
++    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
++    QVariant data(const QModelIndex& index, int role) const override;
++    QHash<int, QByteArray> roleNames() const override {
++        QHash<int, QByteArray> roleNames { {SurfaceRole, "surface"},
++                                           {ApplicationRole, "application"},
++                                           {IdRole, "id"} };
++        return roleNames;
++    }
++
++    int nextId() const { return m_nextId; }
++
++    QAbstractListModel *applicationsModel() const;
++    void setApplicationsModel(QAbstractListModel*);
++
++public Q_SLOTS:
++    /**
++     * @brief Returns the surface at the given index
++     *
++     * It will be a nullptr if the application is still starting up and thus hasn't yet created
++     * and drawn into a surface.
++     */
++    unity::shell::application::MirSurfaceInterface *surfaceAt(int index) const;
++
++    /**
++     * @brief Returns the application at the given index
++     */
++    unity::shell::application::ApplicationInfoInterface *applicationAt(int index) const;
++
++    /**
++     * @brief Returns the unique id of the element at the given index
++     */
++    int idAt(int index) const;
++
++    /**
++     * @brief Returns the index where the row with the given id is located
++     *
++     * Returns -1 if there's no row with the given id.
++     */
++    int indexForId(int id) const;
++
++    /**
++     * @brief Raises the row with the given id to index 0
++     */
++    void raiseId(int id);
++
++    void doRaiseId(int id);
++
++Q_SIGNALS:
++    void countChanged();
++
++    /**
++     * @brief Emitted when the list changes
++     *
++     * Emitted when model gains an element, loses an element or when elements exchange positions.
++     */
++    void listChanged();
++
++    void nextIdChanged();
++
++    void applicationsModelChanged();
++
++private:
++    void addApplication(unity::shell::application::ApplicationInfoInterface *application);
++    void removeApplication(unity::shell::application::ApplicationInfoInterface *application);
++
++    int indexOf(unity::shell::application::MirSurfaceInterface *surface);
++    void raise(unity::shell::application::MirSurfaceInterface *surface);
++    void move(int from, int to);
++    void appendSurfaceHelper(unity::shell::application::MirSurfaceInterface *surface,
++                              unity::shell::application::ApplicationInfoInterface *application);
++    void connectSurface(unity::shell::application::MirSurfaceInterface *surface);
++    int generateId();
++    int nextFreeId(int candidateId);
++    QString toString();
++    void onSurfaceDestroyed(unity::shell::application::MirSurfaceInterface *surface);
++    void onSurfaceDied(unity::shell::application::MirSurfaceInterface *surface);
++    void removeAt(int index);
++    void findApplicationRole();
++
++    unity::shell::application::ApplicationInfoInterface *getApplicationFromModelAt(int index);
++
++    /*
++        Placeholder for a future surface from a starting or running application.
++        Enables shell to give immediate feedback to the user by showing, eg,
++        a splash screen.
++
++        It's a model row containing a null surface and the given application.
++     */
++    void appendPlaceholder(unity::shell::application::ApplicationInfoInterface *application);
++
++    /*
++        Adds a model row with the given surface and application
++
++        Alternatively, if a placeholder exists for the given application it's
++        filled with the given surface instead.
++     */
++    void appendSurface(unity::shell::application::MirSurfaceInterface *surface,
++            unity::shell::application::ApplicationInfoInterface *application);
++
++    struct ModelEntry {
++        ModelEntry(unity::shell::application::MirSurfaceInterface *surface, unity::shell::application::ApplicationInfoInterface *application, int id)
++            : surface(surface), application(application), id(id) {}
++        unity::shell::application::MirSurfaceInterface *surface;
++        unity::shell::application::ApplicationInfoInterface *application;
++        int id;
++        bool removeOnceSurfaceDestroyed{false};
++    };
++
++    QList<ModelEntry> m_surfaceList;
++    int m_nextId{1};
++    static const int m_maxId{1000000};
++
++    // applications that are being monitored
++    QList<unity::shell::application::ApplicationInfoInterface *> m_applications;
++
++    QAbstractListModel* m_applicationsModel{nullptr};
++    int m_applicationRole{-1};
++
++    enum ModelState {
++        IdleState,
++        InsertingState,
++        RemovingState,
++        MovingState,
++        ResettingState
++    };
++    ModelState m_modelState{IdleState};
++};
++
++Q_DECLARE_METATYPE(TopLevelSurfaceList*)
++Q_DECLARE_METATYPE(QAbstractListModel*)
++
++#endif // TOPLEVELSURFACELIST_H
 === added file 'plugins/WindowManager/WindowManagerPlugin.cpp'
 --- plugins/WindowManager/WindowManagerPlugin.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/WindowManagerPlugin.cpp	2016-04-20 17:09:16 +0000
@@ -0,0 +1,28 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "WindowManagerPlugin.h"
++
++#include "TopLevelSurfaceList.h"
++
++#include <QtQml>
++
++void WindowManagerPlugin::registerTypes(const char *uri)
++{
++    qmlRegisterType<TopLevelSurfaceList>(uri, 0, 1, "TopLevelSurfaceList");
++
++    qRegisterMetaType<QAbstractListModel*>("QAbstractListModel*");
++}
 === added file 'plugins/WindowManager/WindowManagerPlugin.h'
 --- plugins/WindowManager/WindowManagerPlugin.h	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/WindowManagerPlugin.h	2016-04-20 17:09:16 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef WINDOWMANAGER_PLUGIN_H
++#define WINDOWMANAGER_PLUGIN_H
++
++#include <QtQml/QQmlEngine>
++#include <QtQml/QQmlExtensionPlugin>
++
++class WindowManagerPlugin : public QQmlExtensionPlugin
++{
++    Q_OBJECT
++    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
++
++public:
++    void registerTypes(const char *uri) override;
++};
++
++#endif // WINDOWMANAGER_PLUGIN_H
 === added file 'plugins/WindowManager/qmldir'
 --- plugins/WindowManager/qmldir	1970-01-01 00:00:00 +0000
 +++ plugins/WindowManager/qmldir	2016-04-20 17:09:16 +0000
@@ -0,0 +1,2 @@
++module WindowManager
++plugin windowmanager-qml
 === modified file 'qml/Components/KeymapSwitcher.qml'
 --- qml/Components/KeymapSwitcher.qml	2016-04-20 17:09:15 +0000
 +++ qml/Components/KeymapSwitcher.qml	2016-04-20 17:09:16 +0000
@@ -57,16 +57,8 @@
          currentKeymapIndex = prevIndex;
+     }
--    // Code below will get much simpler with surface-based window management (the upcoming MirFocusController)
--    property var application: ApplicationManager.focusedApplicationId
--            ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)
--            : null
--    property var session: application && application.session ? application.session : null
--    property var surface: session ? session.lastSurface : null
--
      property Binding surfaceKeymapBinding: Binding {
--        target: root.surface
--        when: root.surface != null && root.surface.live
++        target: MirFocusController.focusedSurface
          property: "keymap"
          value: root.currentKeymap
+     }
 === modified file 'qml/Greeter/Greeter.qml'
 --- qml/Greeter/Greeter.qml	2016-03-30 07:46:17 +0000
 +++ qml/Greeter/Greeter.qml	2016-04-20 17:09:16 +0000
@@ -64,7 +64,7 @@
          d.selectUser(d.currentIndex, true);
+     }
--    function notifyAppFocused(appId) {
++    function notifyAppFocusRequested(appId) {
          if (!active) {
              return;
+         }
@@ -81,19 +81,20 @@
+         }
+     }
--    function notifyAboutToFocusApp(appId) {
++    // Notify that the user has explicitly requested the given app through unity8 GUI.
++    function notifyUserRequestedApp(appId) {
          if (!active) {
              return;
+         }
          // A hint that we're about to focus an app.  This way we can look
          // a little more responsive, rather than waiting for the above
--        // notifyAppFocused call.  We also need this in case we have a locked
++        // notifyAppFocusRequested call.  We also need this in case we have a locked
          // app, in order to show lockscreen instead of new app.
          d.startUnlock(false /* toTheRight */);
+     }
--    // This is a just a glorified notifyAboutToFocusApp(), but it does one
++    // This is a just a glorified notifyUserRequestedApp(), but it does one
      // other thing: it hides any cover pages to the RIGHT, because the user
      // just came from a launcher drag starting on the left.
      // It also returns a boolean value, indicating whether there was a visual
 === modified file 'qml/Launcher/LauncherPanel.qml'
 --- qml/Launcher/LauncherPanel.qml	2016-03-16 11:20:24 +0000
 +++ qml/Launcher/LauncherPanel.qml	2016-04-20 17:09:16 +0000
@@ -98,6 +98,7 @@
              AbstractButton {
                  id: dashItem
                  anchors.fill: parent
++                activeFocusOnPress: false
                  onClicked: root.showDashHome()
+             }
              Rectangle {
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2016-04-20 17:09:15 +0000
 +++ qml/Shell.qml	2016-04-20 17:09:16 +0000
@@ -42,6 +42,7 @@
  import Unity.DashCommunicator 0.1
  import Unity.Indicators 0.1 as Indicators
  import Cursor 1.0
++import WindowManager 0.1
  Item {
@@ -96,13 +97,45 @@
+         }
+     }
++    readonly property var mainApp:
++            applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null
++    onMainAppChanged: {
++        if (mainApp) {
++            _onMainAppChanged(mainApp.appId);
++        }
++    }
++    Connections {
++        target: ApplicationManager
++        onFocusRequested: {
++            if (shell.mainApp && shell.mainApp.appId === appId) {
++                _onMainAppChanged(appId);
++            }
++        }
++    }
++    function _onMainAppChanged(appId) {
++        if (wizard.active && appId != "" && appId != "unity8-dash") {
++            // If this happens on first boot, we may be in edge
++            // tutorial or wizard while receiving a call.  But a call
++            // is more important than wizard so just bail out of those.
++            tutorial.finish();
++            wizard.hide();
++        }
++
++        if (appId === "dialer-app" && callManager.hasCalls && greeter.locked) {
++            // If we are in the middle of a call, make dialer lockedApp and show it.
++            // This can happen if user backs out of dialer back to greeter, then
++            // launches dialer again.
++            greeter.lockedApp = appId;
++        }
++        greeter.notifyAppFocusRequested(appId);
++
++        panel.indicators.hide();
++        launcher.hide();
++    }
++
      // For autopilot consumption
      readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
--    // internal props from here onwards
--    readonly property var mainApp:
--            applicationsDisplayLoader.item ? applicationsDisplayLoader.item.mainApp : null
--
      // Disable everything while greeter is waiting, so that the user can't swipe
      // the greeter or launcher until we know whether the session is locked.
      enabled: greeter && !greeter.waiting
@@ -139,9 +172,6 @@
      Component.onCompleted: {
          theme.name = "Ubuntu.Components.Themes.SuruDark"
--        if (ApplicationManager.count > 0) {
--            ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
--        }
          finishStartUpTimer.start();
+     }
@@ -198,36 +228,10 @@
          width: parent.width
          height: parent.height
--        Connections {
--            target: ApplicationManager
--
--            // This signal is also fired when we try to focus the current app
--            // again.  We rely on this!
--            onFocusedApplicationIdChanged: {
--                var appId = ApplicationManager.focusedApplicationId;
--
--                if (wizard.active && appId != "" && appId != "unity8-dash") {
--                    // If this happens on first boot, we may be in edge
--                    // tutorial or wizard while receiving a call.  But a call
--                    // is more important than wizard so just bail out of those.
--                    tutorial.finish();
--                    wizard.hide();
--                }
--
--                if (appId === "dialer-app" && callManager.hasCalls && greeter.locked) {
--                    // If we are in the middle of a call, make dialer lockedApp and show it.
--                    // This can happen if user backs out of dialer back to greeter, then
--                    // launches dialer again.
--                    greeter.lockedApp = appId;
--                }
--                greeter.notifyAppFocused(appId);
--
--                panel.indicators.hide();
--            }
--
--            onApplicationAdded: {
--                launcher.hide();
--            }
++        TopLevelSurfaceList {
++            id: topLevelSurfaceList
++            objectName: "topLevelSurfaceList"
++            applicationsModel: ApplicationManager
+         }
          Loader {
@@ -258,6 +262,10 @@
                      return "Stages/DesktopStage.qml";
+                 }
+             }
++            // TODO: Ensure the current stage is destroyed before the new one gets loaded.
++            //       Currently the new one will get loaded while the old is still hanging
++            //       around for a bit, which might lead to conflicts where both stages
++            //       change the model simultaneously.
              onQmlComponentChanged: {
                  if (item) item.stageAboutToBeUnloaded();
                  source = qmlComponent;
@@ -272,6 +280,11 @@
              Binding {
                  target: applicationsDisplayLoader.item
++                property: "focus"
++                value: true
++            }
++            Binding {
++                target: applicationsDisplayLoader.item
                  property: "objectName"
                  value: "stage"
+             }
@@ -356,6 +369,16 @@
                  property: "leftMargin"
                  value: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0
+             }
++            Binding {
++                target: applicationsDisplayLoader.item
++                property: "applicationManager"
++                value: ApplicationManager
++            }
++            Binding {
++                target: applicationsDisplayLoader.item
++                property: "topLevelSurfaceList"
++                value: topLevelSurfaceList
++            }
+         }
+     }
@@ -370,16 +393,6 @@
          z: notifications.useModal || panel.indicators.shown || wizard.active || tutorial.running ? overlay.z + 1 : overlay.z - 1
+     }
--    Connections {
--        target: SessionManager
--        onSessionStopping: {
--            if (!session.parentSession && !session.application) {
--                // nothing is using it. delete it right away
--                session.release();
--            }
--        }
--    }
--
      Loader {
          id: greeterLoader
          anchors.fill: parent
@@ -471,7 +484,7 @@
+     }
      function showHome() {
--        greeter.notifyAboutToFocusApp("unity8-dash");
++        greeter.notifyUserRequestedApp("unity8-dash");
          var animate = !lightDM.greeter.active && !stages.shown
          dash.setCurrentScope(0, animate, false)
@@ -520,9 +533,10 @@
                  greeterShown: greeter.shown
+             }
--            readonly property bool topmostApplicationIsFullscreen: mainApp && mainApp.fullscreen
--
--            fullscreenMode: (topmostApplicationIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)
++            readonly property bool focusedSurfaceIsFullscreen: MirFocusController.focusedSurface
++                ? MirFocusController.focusedSurface.state === Mir.FullscreenState
++                : false
++            fullscreenMode: (focusedSurfaceIsFullscreen && !lightDM.greeter.active && launcher.progress == 0)
                              || greeter.hasLockedApp
              locked: greeter && greeter.active
+         }
@@ -555,7 +569,7 @@
+                 }
+             }
              onLauncherApplicationSelected: {
--                greeter.notifyAboutToFocusApp(appId);
++                greeter.notifyUserRequestedApp(appId);
                  shell.activateApplication(appId);
+             }
              onShownChanged: {
@@ -719,7 +733,7 @@
          onMouseMoved: { cursor.opacity = 1; }
+     }
--    // non-visual item
++    // non-visual object
      KeymapSwitcher {}
      Rectangle {
 === modified file 'qml/Stages/AbstractStage.qml'
 --- qml/Stages/AbstractStage.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/AbstractStage.qml	2016-04-20 17:09:16 +0000
@@ -18,12 +18,19 @@
  import Ubuntu.Components 1.3
  import GSettings 1.0
--Rectangle {
++FocusScope {
      id: root
--    color: "#060606"
++    property alias color: backRect.color
++    Rectangle {
++        id: backRect
++        color: "#060606"
++        anchors.fill: parent
++    }
      // Controls to be set from outside
++    property QtObject applicationManager
++    property QtObject topLevelSurfaceList
      property bool altTabPressed
      property url background
      property bool beingResized
 === removed directory 'qml/Stages/Animations'
 === removed file 'qml/Stages/Animations/BaseSessionAnimation.qml'
 --- qml/Stages/Animations/BaseSessionAnimation.qml	2015-07-15 15:07:19 +0000
 +++ qml/Stages/Animations/BaseSessionAnimation.qml	1970-01-01 00:00:00 +0000
@@ -1,96 +0,0 @@
--/*
-- * 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.4
--
--/* This is the base case for surface animations, used when adding/removing * child surfaces.
-- * The class is meant to be overridden and changes/animations provided for state changes.
-- * NB. It is important to release the surface at the end of the "out" animation.
-- *
-- * Example - Simple fade in/out
-- *
-- * BaseSurfaceAnimation {
-- *     outChanges: [ PropertyChanges { target: animation.surface; opacity: 0.0 } ]
-- *     outAnimations: [
--           SequentialAnimation {
-- *             NumberAnimation { target: animation.surface; property: "opacity"; duration: 300 }
-- *             ScriptAction { script: { if (animation.parent.removing) animation.surface.release(); } }
-- *         }
-- *     ]
-- *
-- *     inChanges: [ PropertyChanges { target: animation.surface; opacity: 1.0 } ]
-- *     inAnimations: [ NumberAnimation { target: animation.surface; property: "opacity"; duration: 300 } ]
-- * }
-- */
--Item {
--    id: base
--    property var container
--    objectName: "sessionAnimation"
--
--    // changes applied when state changes to "from"
--    property list<QtObject> fromChanges
--    // transition animations when changing state to "from"
--    property list<QtObject> fromAnimations
--
--    // changes applied when state changes to "to"
--    property list<QtObject> toChanges
--    // transition animations when changing state to "to"
--    property list<QtObject> toAnimations
--
--    function start() {
--        // "prep" state forces toChanges without transition animations.
--        state = "prep"
--        state = "to";
--    }
--    function end() {
--        state = "from";
--    }
--
--    signal completed()
--
--    states: [
--        State {
--            name: "baseAnimation"
--            PropertyChanges { target: container; anchors.fill: undefined }
--        },
--
--        State {
--            name: "prep"
--            extend: "baseAnimation"
--            changes: fromChanges
--        },
--        State {
--            name: "from"
--            extend: "prep"
--        },
--        State {
--            name: "in"
--            extend: "baseAnimation"
--            changes: toChanges
--        }
--    ]
--
--    transitions: [
--        Transition {
--            to:  "from"
--            animations: fromAnimations
--        },
--        Transition {
--            to: "to"
--            animations: toAnimations
--        }
--    ]
--}
 === removed file 'qml/Stages/Animations/SwipeFromBottomAnimation.qml'
 --- qml/Stages/Animations/SwipeFromBottomAnimation.qml	2015-07-15 15:07:19 +0000
 +++ qml/Stages/Animations/SwipeFromBottomAnimation.qml	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
--/*
-- * 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.4
--import Ubuntu.Components 1.3
--
--BaseSessionAnimation {
--    id: animation
--
--    fromChanges: [
--        AnchorChanges {
--            target: container;
--            anchors.top: container.parent.bottom
--        }
--    ]
--    fromAnimations: [
--        SequentialAnimation {
--            // clip so we don't go out of parent's bounds during spread
--            PropertyAction { target: container.parent; property: "clip"; value: true }
--            AnchorAnimation { easing: UbuntuAnimation.StandardEasing; duration: UbuntuAnimation.BriskDuration }
--            PropertyAction { target: container.parent; property: "clip"; value: false }
--            ScriptAction { script: { animation.completed(); } }
--        }
--    ]
--
--    toChanges: [
--        AnchorChanges {
--            target: container;
--            anchors.top: container.parent.top
--        }
--    ]
--    toAnimations: [
--        SequentialAnimation {
--            // clip so we don't go out of parent's bounds during spread
--            PropertyAction { target: container.parent; property: "clip"; value: true }
--            AnchorAnimation { easing: UbuntuAnimation.StandardEasing; duration: UbuntuAnimation.BriskDuration }
--            PropertyAction { target: container.parent; property: "clip"; value: false }
--        }
--    ]
--}
 === modified file 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/ApplicationWindow.qml	2016-04-20 17:09:16 +0000
@@ -20,35 +20,77 @@
  FocusScope {
      id: root
--    implicitWidth: sessionContainer.implicitWidth
--    implicitHeight: sessionContainer.implicitHeight
++    implicitWidth: surfaceContainer.implicitWidth
++    implicitHeight: surfaceContainer.implicitHeight
      // to be read from outside
--    property alias interactive: sessionContainer.interactive
++    property alias interactive: surfaceContainer.interactive
      property bool orientationChangesEnabled: d.supportsSurfaceResize ? d.surfaceOldEnoughToBeResized : true
--    readonly property string title: sessionContainer.surface && sessionContainer.surface.name !== "" ?
--                                        sessionContainer.surface.name : d.name
++    readonly property string title: surface && surface.name !== "" ? surface.name : d.name
      // overridable from outside
--    property bool fullscreen: application ? application.fullscreen : false
++    property bool fullscreen: {
++        if (surface) {
++            return surface.state === Mir.FullscreenState;
++        } else if (application) {
++            return application.fullscreen;
++        } else {
++            return false;
++        }
++    }
      // to be set from outside
++    property QtObject surface
      property QtObject application
      property int surfaceOrientationAngle
--    property alias resizeSurface: sessionContainer.resizeSurface
++    property alias resizeSurface: surfaceContainer.resizeSurface
      property int requestedWidth: -1
      property int requestedHeight: -1
--    readonly property int minimumWidth: sessionContainer.surface ? sessionContainer.surface.minimumWidth : 0
--    readonly property int minimumHeight: sessionContainer.surface ? sessionContainer.surface.minimumHeight : 0
--    readonly property int maximumWidth: sessionContainer.surface ? sessionContainer.surface.maximumWidth : 0
--    readonly property int maximumHeight: sessionContainer.surface ? sessionContainer.surface.maximumHeight : 0
--    readonly property int widthIncrement: sessionContainer.surface ? sessionContainer.surface.widthIncrement : 0
--    readonly property int heightIncrement: sessionContainer.surface ? sessionContainer.surface.heightIncrement : 0
++    readonly property int minimumWidth: surface ? surface.minimumWidth : 0
++    readonly property int minimumHeight: surface ? surface.minimumHeight : 0
++    readonly property int maximumWidth: surface ? surface.maximumWidth : 0
++    readonly property int maximumHeight: surface ? surface.maximumHeight : 0
++    readonly property int widthIncrement: surface ? surface.widthIncrement : 0
++    readonly property int heightIncrement: surface ? surface.heightIncrement : 0
++
++    onSurfaceChanged: {
++        // The order in which the instructions are executed here matters, to that the correct state
++        // transitions in stateGroup take place.
++        // More specifically, the moment surfaceContainer.surface gets updated relative to the
++        // other instructions.
++        if (surface) {
++            surfaceContainer.surface = surface;
++            d.liveSurface = surface.live;
++            d.hadSurface = false;
++            surfaceInitTimer.start();
++        } else {
++            if (d.surfaceInitialized) {
++                d.hadSurface = true;
++            }
++            d.surfaceInitialized = false;
++            surfaceContainer.surface = null;
++        }
++    }
      QtObject {
          id: d
++        property bool liveSurface: false;
++        property var con: Connections {
++            target: root.surface
++            onLiveChanged: d.liveSurface = root.surface.live
++        }
++        // using liveSurface instead of root.surface.live because with the latter
++        // this expression is not reevaluated when root.surface changes
++        readonly property bool needToTakeScreenshot: root.surface && d.surfaceInitialized && !d.liveSurface
++                                                  && applicationState !== ApplicationInfoInterface.Running
++        onNeedToTakeScreenshotChanged: {
++            if (needToTakeScreenshot && screenshotImage.status === Image.Null) {
++                screenshotImage.take();
++            }
++        }
++
          // helpers so that we don't have to check for the existence of an application everywhere
          // (in order to avoid breaking qml binding due to a javascript exception)
          readonly property string name: root.application ? root.application.name : ""
@@ -62,17 +104,7 @@
          readonly property color splashColorFooter: root.application ? root.application.splashColorFooter : "#00000000"
          // Whether the Application had a surface before but lost it.
--        property bool hadSurface: sessionContainer.surfaceContainer.hadSurface
--
--        readonly property bool needToTakeScreenshot:
--            ((sessionContainer.surface && d.surfaceInitialized) || d.hadSurface)
--            && screenshotImage.status === Image.Null
--            && d.applicationState === ApplicationInfoInterface.Stopped
--        onNeedToTakeScreenshotChanged: {
--            if (needToTakeScreenshot) {
--                screenshotImage.take();
--            }
--        }
++        property bool hadSurface: false
          //FIXME - this is a hack to avoid the first few rendered frames as they
          // might show the UI accommodating due to surface resizes on startup.
@@ -99,7 +131,9 @@
      Timer {
          id: surfaceInitTimer
          interval: 100
--        onTriggered: { if (sessionContainer.surface) {d.surfaceInitialized = true;} }
++        onTriggered: {
++            if (root.surface && root.surface.live) {d.surfaceInitialized = true;}
++        }
+     }
      Timer {
@@ -117,7 +151,7 @@
          function take() {
              // Save memory by using a half-resolution (thus quarter size) screenshot.
              // Do not make this a binding, we can only take the screenshot once!
--            sessionContainer.grabToImage(
++            surfaceContainer.grabToImage(
                  function(result) {
                      screenshotImage.source = result.url;
                  },
@@ -144,46 +178,33 @@
+         }
+     }
--    SessionContainer {
--        id: sessionContainer
--        // A fake application might not even have a session property.
--        session: application && application.session ? application.session : null
--
++    SurfaceContainer {
++        id: surfaceContainer
          requestedWidth: root.requestedWidth
          requestedHeight: root.requestedHeight
--
          surfaceOrientationAngle: application && application.rotatesWindowContents ? root.surfaceOrientationAngle : 0
--
--        onSurfaceChanged: {
--            if (sessionContainer.surface) {
--                surfaceInitTimer.start();
--            } else {
--                d.surfaceInitialized = false;
--            }
--        }
--
          focus: true
+     }
--    // SessionContainer size drives ApplicationWindow size
++    // SurfaceContainer size drives ApplicationWindow size
      Binding {
          target: root; property: "width"
--        value: stateGroup.state === "surface" ? sessionContainer.width : root.requestedWidth
++        value: stateGroup.state === "surface" ? surfaceContainer.width : root.requestedWidth
          when: root.requestedWidth >= 0
+     }
      Binding {
          target: root; property: "height"
--        value: stateGroup.state === "surface" ? sessionContainer.height : root.requestedHeight
++        value: stateGroup.state === "surface" ? surfaceContainer.height : root.requestedHeight
          when: root.requestedHeight >= 0
+     }
--    // ApplicationWindow size drives SessionContainer size
++    // ApplicationWindow size drives SurfaceContainer size
      Binding {
--        target: sessionContainer; property: "width"; value: root.width
++        target: surfaceContainer; property: "width"; value: root.width
          when: root.requestedWidth < 0
+     }
      Binding {
--        target: sessionContainer; property: "height"; value: root.height
++        target: surfaceContainer; property: "height"; value: root.height
          when: root.requestedHeight < 0
+     }
@@ -194,32 +215,43 @@
              State {
                  name: "void"
                  when:
--                     d.hadSurface && (!sessionContainer.surface || !d.surfaceInitialized)
++                     d.hadSurface && (!root.surface || !d.surfaceInitialized)
                       &&
                       screenshotImage.status !== Image.Ready
              },
              State {
                  name: "splashScreen"
                  when:
--                     !d.hadSurface && (!sessionContainer.surface || !d.surfaceInitialized)
++                     !d.hadSurface && (!root.surface || !d.surfaceInitialized)
                       &&
                       screenshotImage.status !== Image.Ready
              },
              State {
                  name: "surface"
                  when:
--                      (sessionContainer.surface && d.surfaceInitialized)
++                      (root.surface && d.surfaceInitialized)
                        &&
--                      (d.applicationState !== ApplicationInfoInterface.Stopped
--                       || screenshotImage.status !== Image.Ready)
++                      (d.liveSurface ||
++                       (d.applicationState !== ApplicationInfoInterface.Running
++                        && screenshotImage.status !== Image.Ready))
              },
              State {
                  name: "screenshot"
                  when:
                        screenshotImage.status === Image.Ready
                        &&
--                      (d.applicationState === ApplicationInfoInterface.Stopped
--                       || !sessionContainer.surface || !d.surfaceInitialized)
++                      (d.applicationState !== ApplicationInfoInterface.Running
++                       || !root.surface || !d.surfaceInitialized)
++            },
++            State {
++                // This is a dead end. From here we expect the surface to be removed from the model
++                // shortly after we stop referencing to it in our SurfaceContainer.
++                name: "closed"
++                when:
++                      // The surface died while the application is running. It must have been closed
++                      // by the shell or the application decided to destroy it by itself
++                      root.surface && d.surfaceInitialized && !d.liveSurface
++                      && d.applicationState === ApplicationInfoInterface.Running
+             }
+         ]
@@ -227,17 +259,17 @@
              Transition {
                  from: ""; to: "splashScreen"
                  PropertyAction { target: splashLoader; property: "active"; value: true }
--                PropertyAction { target: sessionContainer.surfaceContainer
++                PropertyAction { target: surfaceContainer
                                   property: "visible"; value: false }
              },
              Transition {
                  from: "splashScreen"; to: "surface"
                  SequentialAnimation {
--                    PropertyAction { target: sessionContainer.surfaceContainer
++                    PropertyAction { target: surfaceContainer
                                       property: "opacity"; value: 0.0 }
--                    PropertyAction { target: sessionContainer.surfaceContainer
++                    PropertyAction { target: surfaceContainer
                                       property: "visible"; value: true }
--                    UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";
++                    UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";
                                              from: 0.0; to: 1.0
                                              duration: UbuntuAnimation.BriskDuration }
                      ScriptAction { script: {
@@ -253,12 +285,12 @@
                          surfaceIsOldTimer.stop();
                          d.surfaceOldEnoughToBeResized = false;
                          splashLoader.active = true;
--                        sessionContainer.surfaceContainer.visible = true;
++                        surfaceContainer.visible = true;
                      } }
                      UbuntuNumberAnimation { target: splashLoader; property: "opacity";
                                              from: 0.0; to: 1.0
                                              duration: UbuntuAnimation.BriskDuration }
--                    PropertyAction { target: sessionContainer.surfaceContainer
++                    PropertyAction { target: surfaceContainer
                                       property: "visible"; value: false }
+                 }
              },
@@ -274,15 +306,16 @@
                                              from: 0.0; to: 1.0
                                              duration: UbuntuAnimation.BriskDuration }
                      ScriptAction { script: {
--                        sessionContainer.surfaceContainer.visible = false;
--                        if (sessionContainer.session) { sessionContainer.session.release(); }
++                        surfaceContainer.visible = false;
++                        surfaceContainer.surface = null;
++                        d.hadSurface = true;
                      } }
+                 }
              },
              Transition {
                  from: "screenshot"; to: "surface"
                  SequentialAnimation {
--                    PropertyAction { target: sessionContainer.surfaceContainer
++                    PropertyAction { target: surfaceContainer
                                       property: "visible"; value: true }
                      UbuntuNumberAnimation { target: screenshotImage; property: "opacity";
                                              from: 1.0; to: 0.0
@@ -310,22 +343,31 @@
                  ScriptAction { script: {
                      surfaceIsOldTimer.stop();
                      d.surfaceOldEnoughToBeResized = false;
--                    sessionContainer.surfaceContainer.visible = false;
--                    if (sessionContainer.session) { sessionContainer.session.release(); }
++                    surfaceContainer.visible = false;
                  } }
              },
              Transition {
                  from: "void"; to: "surface"
                  SequentialAnimation {
--                    PropertyAction { target: sessionContainer.surfaceContainer; property: "opacity"; value: 0.0 }
--                    PropertyAction { target: sessionContainer.surfaceContainer; property: "visible"; value: true }
--                    UbuntuNumberAnimation { target: sessionContainer.surfaceContainer; property: "opacity";
++                    PropertyAction { target: surfaceContainer; property: "opacity"; value: 0.0 }
++                    PropertyAction { target: surfaceContainer; property: "visible"; value: true }
++                    UbuntuNumberAnimation { target: surfaceContainer; property: "opacity";
                                              from: 0.0; to: 1.0
                                              duration: UbuntuAnimation.BriskDuration }
                      ScriptAction { script: {
                          surfaceIsOldTimer.start();
                      } }
+                 }
++            },
++            Transition {
++                to: "closed"
++                SequentialAnimation {
++                    ScriptAction { script: {
++                        surfaceContainer.visible = false;
++                        surfaceContainer.surface = null;
++                        d.hadSurface = true;
++                    } }
++                }
+             }
+         ]
+     }
 === modified file 'qml/Stages/DecoratedWindow.qml'
 --- qml/Stages/DecoratedWindow.qml	2016-02-17 13:17:12 +0000
 +++ qml/Stages/DecoratedWindow.qml	2016-04-20 17:09:16 +0000
@@ -26,10 +26,10 @@
      width: applicationWindow.width
      height: (decorationShown ? decoration.height : 0) + applicationWindow.height
--    property alias window: applicationWindow
      property alias application: applicationWindow.application
++    property alias surface: applicationWindow.surface
      property alias active: decoration.active
--    property alias title: decoration.title
++    readonly property alias title: applicationWindow.title
      property alias fullscreen: applicationWindow.fullscreen
      readonly property bool decorationShown: !fullscreen
@@ -79,11 +79,11 @@
      WindowDecoration {
          id: decoration
          target: root.parent
--        objectName: application ? "appWindowDecoration_" + application.appId : "appWindowDecoration_null"
++        objectName: "appWindowDecoration"
          anchors { left: parent.left; top: parent.top; right: parent.right }
          height: units.gu(3)
          width: root.width
--        title: window.title
++        title: applicationWindow.title
          visible: root.decorationShown
          onClose: root.close();
@@ -94,7 +94,7 @@
      ApplicationWindow {
          id: applicationWindow
--        objectName: application ? "appWindow_" + application.appId : "appWindow_null"
++        objectName: "appWindow"
          anchors.top: parent.top
          anchors.topMargin: decoration.height
          anchors.left: parent.left
 === modified file 'qml/Stages/DesktopSpread.qml'
 --- qml/Stages/DesktopSpread.qml	2016-03-10 22:39:57 +0000
 +++ qml/Stages/DesktopSpread.qml	2016-04-20 17:09:16 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2015 Canonical, Ltd.
++ * Copyright (C) 2015-2016 Canonical, Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
@@ -20,6 +20,7 @@
  import Ubuntu.Gestures 0.1
  import Unity.Application 0.1
  import "../Components"
++import Utils 0.1
  FocusScope {
      id: root
@@ -69,12 +70,12 @@
+     }
      function selectNext(isAutoRepeat) {
--        if (isAutoRepeat && spreadRepeater.highlightedIndex >= ApplicationManager.count -1) {
++        if (isAutoRepeat && spreadRepeater.highlightedIndex >= topLevelSurfaceList.count -1) {
              return; // AutoRepeat is not allowed to wrap around
+         }
--        spreadRepeater.highlightedIndex = (spreadRepeater.highlightedIndex + 1) % ApplicationManager.count;
--        var newContentX = ((spreadFlickable.contentWidth) / (ApplicationManager.count + 1)) * Math.max(0, Math.min(ApplicationManager.count - 5, spreadRepeater.highlightedIndex - 3));
++        spreadRepeater.highlightedIndex = (spreadRepeater.highlightedIndex + 1) % topLevelSurfaceList.count;
++        var newContentX = ((spreadFlickable.contentWidth) / (topLevelSurfaceList.count + 1)) * Math.max(0, Math.min(topLevelSurfaceList.count - 5, spreadRepeater.highlightedIndex - 3));
          if (spreadFlickable.contentX < newContentX || spreadRepeater.highlightedIndex == 0) {
              spreadFlickable.snapTo(newContentX)
+         }
@@ -85,10 +86,10 @@
              return; // AutoRepeat is not allowed to wrap around
+         }
--        var newIndex = spreadRepeater.highlightedIndex - 1 >= 0 ? spreadRepeater.highlightedIndex - 1 : ApplicationManager.count - 1;
++        var newIndex = spreadRepeater.highlightedIndex - 1 >= 0 ? spreadRepeater.highlightedIndex - 1 : topLevelSurfaceList.count - 1;
          spreadRepeater.highlightedIndex = newIndex;
--        var newContentX = ((spreadFlickable.contentWidth) / (ApplicationManager.count + 1)) * Math.max(0, Math.min(ApplicationManager.count - 5, spreadRepeater.highlightedIndex - 1));
--        if (spreadFlickable.contentX > newContentX || newIndex == ApplicationManager.count -1) {
++        var newContentX = ((spreadFlickable.contentWidth) / (topLevelSurfaceList.count + 1)) * Math.max(0, Math.min(topLevelSurfaceList.count - 5, spreadRepeater.highlightedIndex - 1));
++        if (spreadFlickable.contentX > newContentX || newIndex == topLevelSurfaceList.count -1) {
              spreadFlickable.snapTo(newContentX)
+         }
+     }
@@ -98,8 +99,8 @@
              if (spreadContainer.visible) {
                  root.playFocusAnimation(spreadRepeater.highlightedIndex)
+             }
--            var application = ApplicationManager.get(spreadRepeater.highlightedIndex);
--            ApplicationManager.requestFocusApplication(application.appId);
++            var surface = topLevelSurfaceList.surfaceAt(spreadRepeater.highlightedIndex);
++            surface.requestFocus();
+         }
+     }
@@ -144,7 +145,7 @@
          Repeater {
              id: spreadRepeater
              objectName: "spreadRepeater"
--            model: ApplicationManager
++            model: topLevelSurfaceList
              property int highlightedIndex: -1
              property int closingIndex: -1
@@ -182,7 +183,8 @@
                      objectName: "clippedSpreadDelegate"
                      anchors.left: parent.left
                      anchors.top: parent.top
--                    application: ApplicationManager.get(index)
++                    application: model.application
++                    surface: model.surface
                      width: spreadMaths.spreadHeight
                      height: spreadMaths.spreadHeight
@@ -216,7 +218,7 @@
                      id: spreadMaths
                      flickable: spreadFlickable
                      itemIndex: index
--                    totalItems: Math.max(6, ApplicationManager.count)
++                    totalItems: Math.max(6, topLevelSurfaceList.count)
                      sceneHeight: root.height
                      itemHeight: spreadDelegate.height
+                 }
@@ -310,7 +312,7 @@
                              Layout.preferredWidth: height * 8 / 7.6
                              image: Image {
                                  anchors.fill: parent
--                                source: model.icon
++                                source: model.application.icon
                                  Rectangle {
                                      anchors.fill: parent
                                      color: "black"
@@ -324,7 +326,9 @@
                          Label {
                              Layout.fillWidth: true
                              Layout.preferredHeight: units.gu(6)
--                            text: model.name
++                            property string surfaceName: model.surface ? model.surface.name : ""
++                            property string applicationName: model.application ? model.application.name : ""
++                            text: surfaceName ? surfaceName : applicationName
                              wrapMode: Text.WordWrap
                              elide: Text.ElideRight
                              maximumLineCount: 2
@@ -354,7 +358,7 @@
                          anchors.margins: -units.gu(2)
                          onClicked: {
                              spreadRepeater.closingIndex = index;
--                            ApplicationManager.stopApplication(model.appId)
++                            model.surface.close();
+                         }
+                     }
+                 }
@@ -421,7 +425,7 @@
          objectName: "spreadFlickable"
          anchors.fill: parent
          property int minContentWidth: 6 * Math.min(height / 4, width / 5)
--        contentWidth: Math.max(6, ApplicationManager.count) * Math.min(height / 4, width / 5)
++        contentWidth: Math.max(6, topLevelSurfaceList.count) * Math.min(height / 4, width / 5)
          enabled: false
          function snapTo(contentX) {
@@ -523,7 +527,7 @@
      Label {
          id: currentSelectedLabel
          anchors { bottom: parent.bottom; bottomMargin: root.height * 0.625; horizontalCenter: parent.horizontalCenter }
--        text: spreadRepeater.highlightedIndex >= 0 ? ApplicationManager.get(spreadRepeater.highlightedIndex).name : ""
++        text: spreadRepeater.highlightedIndex >= 0 ? topLevelSurfaceList.surfaceAt(spreadRepeater.highlightedIndex).name : ""
          visible: false
          fontSize: "large"
+     }
@@ -545,7 +549,7 @@
              from: "*"
              to: "altTab"
              SequentialAnimation {
--                PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: Math.min(ApplicationManager.count - 1, 1) }
++                PropertyAction { target: spreadRepeater; property: "highlightedIndex"; value: Math.min(topLevelSurfaceList.count - 1, 1) }
                  PauseAnimation { duration: spreadContainer.animateIn ? 0 : 140 }
                  PropertyAction { target: workspaceSelector; property: "visible" }
                  PropertyAction { target: spreadContainer; property: "visible" }
 === modified file 'qml/Stages/DesktopSpreadDelegate.qml'
 --- qml/Stages/DesktopSpreadDelegate.qml	2016-01-11 12:29:30 +0000
 +++ qml/Stages/DesktopSpreadDelegate.qml	2016-04-20 17:09:16 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2014-2015 Canonical, Ltd.
++ * Copyright (C) 2014-2016 Canonical, Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
@@ -25,12 +25,13 @@
      property alias window: applicationWindow
      property alias application: applicationWindow.application
++    property alias surface: applicationWindow.surface
      property bool highlightShown: false
      property real shadowOpacity: 1
--    property int windowWidth: application && application.session && application.session.lastSurface ? application.session.lastSurface.size.width : 0
--    property int windowHeight: application && application.session && application.session.lastSurface ? application.session.lastSurface.size.height : 0
++    property int windowWidth: surface ? surface.size.width : 0
++    property int windowHeight: surface ? surface.size.height : 0
      state: "normal"
      states: [
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/DesktopStage.qml	2016-04-20 17:09:16 +0000
@@ -39,45 +39,18 @@
      // Used by TutorialRight
      property bool spreadShown: spread.state == "altTab"
--    mainApp: ApplicationManager.focusedApplicationId
--            ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)
--            : null
++    mainApp: priv.focusedAppDelegate ? priv.focusedAppDelegate.application : null
      // application windows never rotate independently
      mainAppWindowOrientationAngle: shellOrientationAngle
      orientationChangesEnabled: true
--    Connections {
--        target: ApplicationManager
--        onApplicationAdded: {
--            if (spread.state == "altTab") {
--                spread.state = "";
--            }
--
--            ApplicationManager.focusApplication(appId);
--        }
--
--        onApplicationRemoved: {
--            priv.focusNext();
--        }
--
--        onFocusRequested: {
--            var appIndex = priv.indexOf(appId);
--            var appDelegate = appRepeater.itemAt(appIndex);
--            appDelegate.restore();
--
--            if (spread.state == "altTab") {
--                spread.cancel();
--            }
--        }
--    }
--
      GlobalShortcut {
          id: closeWindowShortcut
          shortcut: Qt.AltModifier|Qt.Key_F4
--        onTriggered: ApplicationManager.stopApplication(priv.focusedAppId)
--        active: priv.focusedAppId !== ""
++        onTriggered: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }
++        active: priv.focusedAppDelegate !== null
+     }
      GlobalShortcut {
@@ -121,40 +94,40 @@
          active: priv.focusedAppDelegate !== null
+     }
++    Connections {
++        target: root.topLevelSurfaceList
++        onCountChanged: {
++            if (spread.state == "altTab") {
++                spread.cancel();
++            }
++        }
++    }
++
      QtObject {
          id: priv
++        objectName: "DesktopStagePrivate"
--        readonly property string focusedAppId: ApplicationManager.focusedApplicationId
--        readonly property var focusedAppDelegate: {
--            var index = indexOf(focusedAppId);
--            return index >= 0 && index < appRepeater.count ? appRepeater.itemAt(index) : null
++        property var focusedAppDelegate: null
++        onFocusedAppDelegateChanged: {
++            if (spread.state == "altTab") {
++                spread.state = "";
++            }
+         }
--        onFocusedAppDelegateChanged: updateForegroundMaximizedApp();
--        property int foregroundMaximizedAppZ: -1
--        property int foregroundMaximizedAppIndex: -1 // for stuff like drop shadow and focusing maximized app by clicking panel
++        property var foregroundMaximizedAppDelegate: null // for stuff like drop shadow and focusing maximized app by clicking panel
          function updateForegroundMaximizedApp() {
--            var tmp = -1;
--            var tmpAppId = -1;
--            for (var i = appRepeater.count - 1; i >= 0; i--) {
++            var found = false;
++            for (var i = 0; i < appRepeater.count && !found; i++) {
                  var item = appRepeater.itemAt(i);
                  if (item && item.visuallyMaximized) {
--                    tmpAppId = i;
--                    tmp = Math.max(tmp, item.normalZ);
--                }
--            }
--            foregroundMaximizedAppZ = tmp;
--            foregroundMaximizedAppIndex = tmpAppId;
--        }
--
--        function indexOf(appId) {
--            for (var i = 0; i < ApplicationManager.count; i++) {
--                if (ApplicationManager.get(i).appId == appId) {
--                    return i;
--                }
--            }
--            return -1;
++                    foregroundMaximizedAppDelegate = item;
++                    found = true;
++                }
++            }
++            if (!found) {
++                foregroundMaximizedAppDelegate = null;
++            }
+         }
          function minimizeAllWindows() {
@@ -164,16 +137,13 @@
                      appDelegate.minimize();
+                 }
+             }
--
--            ApplicationManager.unfocusCurrentApplication(); // no app should have focus at this point
+         }
          function focusNext() {
--            ApplicationManager.unfocusCurrentApplication();
              for (var i = 0; i < appRepeater.count; i++) {
                  var appDelegate = appRepeater.itemAt(i);
                  if (appDelegate && !appDelegate.minimized) {
--                    ApplicationManager.focusApplication(appDelegate.appId);
++                    appDelegate.focus = true;
                      return;
+                 }
+             }
@@ -182,15 +152,14 @@
      Connections {
          target: PanelState
--        onClose: {
--            ApplicationManager.stopApplication(ApplicationManager.focusedApplicationId)
++        onClose: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }
++        onMinimize: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.minimize(); } }
++        onMaximize: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.restoreFromMaximized(); } }
++        onFocusMaximizedApp: {
++            if (priv.foregroundMaximizedAppDelegate) {
++                priv.foregroundMaximizedAppDelegate.focus = true;
++             }
+         }
--        onMinimize: priv.focusedAppDelegate && priv.focusedAppDelegate.minimize();
--        onMaximize: priv.focusedAppDelegate // don't restore minimized apps when double clicking the panel
--                    && priv.focusedAppDelegate.restoreFromMaximized();
--        onFocusMaximizedApp: if (priv.foregroundMaximizedAppIndex != -1) {
--                                 ApplicationManager.focusApplication(appRepeater.itemAt(priv.foregroundMaximizedAppIndex).appId);
--                             }
+     }
      Binding {
@@ -218,7 +187,7 @@
      Binding {
          target: PanelState
          property: "dropShadow"
--        value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppIndex !== -1
++        value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null
+     }
      Component.onDestruction: {
@@ -227,6 +196,27 @@
          PanelState.dropShadow = false;
+     }
++    Instantiator {
++        model: root.applicationManager
++        delegate: Binding {
++            target: model.application
++            property: "requestedState"
++
++            // TODO: figure out some lifecycle policy, like suspending minimized apps
++            //       if running on a tablet or something.
++            // TODO: If the device has a dozen suspended apps because it was running
++            //       in staged mode, when it switches to Windowed mode it will suddenly
++            //       resume all those apps at once. We might want to avoid that.
++            value: ApplicationInfoInterface.RequestedRunning // Always running for now
++        }
++    }
++
++    Binding {
++        target: MirFocusController
++        property: "focusedSurface"
++        value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null
++        when: !appRepeater.startingUp && root.parent
++    }
      FocusScope {
          id: appContainer
@@ -242,20 +232,25 @@
              fillMode: Image.PreserveAspectCrop
+         }
--        Repeater {
++        TopLevelSurfaceRepeater {
              id: appRepeater
--            model: ApplicationManager
++            model: topLevelSurfaceList
              objectName: "appRepeater"
              delegate: FocusScope {
                  id: appDelegate
--                objectName: "appDelegate_" + appId
++                objectName: "appDelegate_" + model.id
                  // z might be overriden in some cases by effects, but we need z ordering
                  // to calculate occlusion detection
--                property int normalZ: ApplicationManager.count - index
++                property int normalZ: topLevelSurfaceList.count - index
++                onNormalZChanged: {
++                    if (visuallyMaximized) {
++                        priv.updateForegroundMaximizedApp();
++                    }
++                }
                  z: normalZ
                  y: PanelState.panelHeight
--                focus: appId === priv.focusedAppId
++
                  width: decoratedWindow.width
                  height: decoratedWindow.height
                  property int requestedWidth: -1
@@ -280,36 +275,99 @@
                  readonly property alias minimized: appDelegatePrivate.minimized
                  readonly property alias fullscreen: decoratedWindow.fullscreen
--                readonly property string appId: model.appId
++                readonly property var application: model.application
                  property bool animationsEnabled: true
                  property alias title: decoratedWindow.title
--                readonly property string appName: model.name
++                readonly property string appName: model.application ? model.application.name : ""
                  property bool visuallyMaximized: false
                  property bool visuallyMinimized: false
++                readonly property var surface: model.surface
++
++                function claimFocus() {
++                    if (spread.state == "altTab") {
++                        spread.cancel();
++                    }
++                    appDelegate.restore();
++                }
++                Connections {
++                    target: model.surface
++                    onFocusRequested: claimFocus();
++                }
++                Connections {
++                    target: model.application
++                    onFocusRequested: {
++                        if (!model.surface) {
++                            // when an app has no surfaces, we assume there's only one entry representing it:
++                            // this delegate.
++                            claimFocus();
++                        } else {
++                            // if the application has surfaces, focus request should be at surface-level.
++                        }
++                    }
++                }
++
                  onFocusChanged: {
--                    if (focus && ApplicationManager.focusedApplicationId !== appId) {
--                        ApplicationManager.focusApplication(appId);
++                    if (appRepeater.startingUp)
++                        return;
++
++                    if (focus) {
++                        priv.focusedAppDelegate = appDelegate;
++
++                        // If we're orphan (!parent) it means this stage is no longer the current one
++                        // and will be deleted shortly. So we should no longer have a say over the model
++                        if (root.parent) {
++                            topLevelSurfaceList.raiseId(model.id);
++                        }
++                    } else if (!focus && priv.focusedAppDelegate === appDelegate) {
++                        priv.focusedAppDelegate = null;
++                        // FIXME: No idea why the Binding{} doens't update when focusedAppDelegate turns null
++                        MirFocusController.focusedSurface = null;
++                    }
++                }
++                Component.onCompleted: {
++                    // NB: We're differentiating if this delegate was created in response to a new entry in the model
++                    //     or if the Repeater is just populating itself with delegates to match the model it received.
++                    if (!appRepeater.startingUp) {
++                        // a top level window is always the focused one when it first appears, unfocusing
++                        // any preexisting one
++                        focus = true;
++                    }
++                }
++                Component.onDestruction: {
++                    if (!root.parent) {
++                        // This stage is about to be destroyed. Don't mess up with the model at this point
++                        return;
++                    }
++
++                    if (visuallyMaximized) {
++                        priv.updateForegroundMaximizedApp();
++                    }
++
++                    if (focus) {
++                        // focus some other window
++                        for (var i = 0; i < appRepeater.count; i++) {
++                            var appDelegate = appRepeater.itemAt(i);
++                            if (appDelegate && !appDelegate.minimized && i != index) {
++                                appDelegate.focus = true;
++                                return;
++                            }
++                        }
+                     }
+                 }
                  onVisuallyMaximizedChanged: priv.updateForegroundMaximizedApp()
--                visible: !visuallyMinimized &&
--                         !greeter.fullyShown &&
--                         (priv.foregroundMaximizedAppZ === -1 || priv.foregroundMaximizedAppZ <= z) ||
--                         decoratedWindow.fullscreen ||
--                         (spread.state == "altTab" && index === spread.highlightedIndex)
++                visible: (
++                          !visuallyMinimized
++                          && !greeter.fullyShown
++                          && (priv.foregroundMaximizedAppDelegate === null || priv.foregroundMaximizedAppDelegate.normalZ <= z)
++                         )
++                         || decoratedWindow.fullscreen
++                         || (spread.state == "altTab" && index === spread.highlightedIndex)
--                Binding {
--                    target: ApplicationManager.get(index)
--                    property: "requestedState"
--                    // TODO: figure out some lifecycle policy, like suspending minimized apps
--                    //       if running on a tablet or something.
--                    // TODO: If the device has a dozen suspended apps because it was running
--                    //       in staged mode, when it switches to Windowed mode it will suddenly
--                    //       resume all those apps at once. We might want to avoid that.
--                    value: ApplicationInfoInterface.RequestedRunning // Always running for now
++                function close() {
++                    model.surface.close();
+                 }
                  function maximize(animated) {
@@ -351,7 +409,8 @@
                          maximizeLeft();
                      else if (maximizedRight)
                          maximizeRight();
--                    ApplicationManager.focusApplication(appId);
++
++                    focus = true;
+                 }
                  function playFocusAnimation() {
@@ -369,7 +428,7 @@
                  states: [
                      State {
--                        name: "fullscreen"; when: decoratedWindow.fullscreen
++                        name: "fullscreen"; when: decoratedWindow.fullscreen && !appDelegate.minimized
                          PropertyChanges {
                              target: appDelegate;
                              x: 0;
@@ -462,6 +521,7 @@
                              ScriptAction {
                                  script: {
                                      if (appDelegate.minimized) {
++                                        appDelegate.focus = false;
                                          priv.focusNext();
+                                     }
+                                 }
@@ -486,7 +546,7 @@
                      id: previewBinding
                      target: appDelegate
                      property: "z"
--                    value: ApplicationManager.count + 1
++                    value: topLevelSurfaceList.count + 1
                      when: index == spread.highlightedIndex && spread.ready
+                 }
@@ -497,12 +557,12 @@
                      minWidth: units.gu(10)
                      minHeight: units.gu(10)
                      borderThickness: units.gu(2)
--                    windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing
++                    windowId: model.application.appId // FIXME: Change this to point to windowId once we have such a thing
                      screenWidth: appContainer.width
                      screenHeight: appContainer.height
                      leftMargin: root.leftMargin
--                    onPressed: { ApplicationManager.focusApplication(model.appId) }
++                    onPressed: { appDelegate.focus = true; }
                      Component.onCompleted: {
                          loadWindowState();
@@ -529,24 +589,25 @@
                      objectName: "decoratedWindow"
                      anchors.left: appDelegate.left
                      anchors.top: appDelegate.top
--                    application: ApplicationManager.get(index)
--                    active: ApplicationManager.focusedApplicationId === model.appId
++                    application: model.application
++                    surface: model.surface
++                    active: appDelegate.focus
                      focus: true
                      requestedWidth: appDelegate.requestedWidth
                      requestedHeight: appDelegate.requestedHeight
--                    onClose: ApplicationManager.stopApplication(model.appId)
++                    onClose: { appDelegate.close(); }
                      onMaximize: appDelegate.maximized || appDelegate.maximizedLeft || appDelegate.maximizedRight
                                  ? appDelegate.restoreFromMaximized() : appDelegate.maximize()
                      onMinimize: appDelegate.minimize()
--                    onDecorationPressed: { ApplicationManager.focusApplication(model.appId) }
++                    onDecorationPressed: { appDelegate.focus = true; }
+                 }
                  WindowedFullscreenPolicy {
                      id: fullscreenPolicy
                      active: true
--                    application: decoratedWindow.application
++                    surface: model.surface
+                 }
+             }
+         }
 === modified file 'qml/Stages/PhoneStage.qml'
 --- qml/Stages/PhoneStage.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/PhoneStage.qml	2016-04-20 17:09:16 +0000
@@ -26,7 +26,6 @@
  AbstractStage {
      id: root
--    property QtObject applicationManager: ApplicationManager
      property bool focusFirstApp: true // If false, focused app will appear on right edge like other apps
      property bool altTabEnabled: true
      property real startScale: 1.1
@@ -107,9 +106,7 @@
+         }
+     }
--    mainApp: applicationManager.focusedApplicationId
--            ? applicationManager.findApplication(applicationManager.focusedApplicationId)
--            : null
++    mainApp: priv.focusedAppDelegate ? priv.focusedAppDelegate.application : null
      orientationChangesEnabled: priv.focusedAppOrientationChangesEnabled
                                 && !priv.focusedAppDelegateIsDislocated
@@ -158,72 +155,27 @@
          onTriggered: { root.beingResized = false; }
+     }
--    Connections {
--        target: applicationManager
--
--        onFocusRequested: {
--            if (spreadView.phase > 0) {
--                spreadView.snapTo(priv.indexOf(appId));
--            } else {
--                applicationManager.focusApplication(appId);
--            }
--        }
--
--        onApplicationAdded: {
--            if (spreadView.phase == 2) {
--                spreadView.snapTo(applicationManager.count - 1);
--            } else {
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--                applicationManager.focusApplication(appId);
--            }
--        }
--
--        onApplicationRemoved: {
--            // Unless we're closing the app ourselves in the spread,
--            // lets make sure the spread doesn't mess up by the changing app list.
--            if (spreadView.closingIndex == -1) {
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--                focusTopMostApp();
--            }
--        }
--
--        function focusTopMostApp() {
--            if (applicationManager.count > 0) {
--                var topmostApp = applicationManager.get(0);
--                applicationManager.focusApplication(topmostApp.appId);
--            }
--        }
--    }
--
      QtObject {
          id: priv
--        property string focusedAppId: root.applicationManager.focusedApplicationId
          property bool focusedAppOrientationChangesEnabled: false
          readonly property int firstSpreadIndex: root.focusFirstApp ? 1 : 0
--        readonly property var focusedAppDelegate: {
--            var index = indexOf(focusedAppId);
--            return index >= 0 && index < spreadRepeater.count ? spreadRepeater.itemAt(index) : null
--        }
++        property var focusedAppDelegate
++        // NB! This may differ from applicationManager.focusedApplicationId if focusedAppDelegate
++        // contains a screenshot instead of a surface.
++        property string focusedAppId: focusedAppDelegate ? focusedAppDelegate.application.appId : ""
          property real oldInverseProgress: 0
          property bool animateX: false
          property int highlightIndex: 0
--        onFocusedAppDelegateChanged: {
--            if (focusedAppDelegate) {
--                focusedAppDelegate.focus = true;
--            }
--        }
--
--        property bool focusedAppDelegateIsDislocated: focusedAppDelegate &&
++        property bool focusedAppDelegateIsDislocated: focusedAppDelegate ?
                                                        (focusedAppDelegate.x !== 0 || focusedAppDelegate.xBehavior.running)
++                                                      : false
          function indexOf(appId) {
--            for (var i = 0; i < root.applicationManager.count; i++) {
--                if (root.applicationManager.get(i).appId == appId) {
++            for (var i = 0; i < spreadRepeater.count; i++) {
++                if (spreadRepeater.itemAt(i).application.appId == appId) {
                      return i;
+                 }
+             }
@@ -237,8 +189,8 @@
          function reset() {
              // The app that's about to go to foreground has to be focused, otherwise
              // it would leave us in an inconsistent state.
--            if (!root.applicationManager.focusedApplicationId && root.applicationManager.count > 0) {
--                root.applicationManager.focusApplication(root.applicationManager.get(0).appId);
++            if (!MirFocusController.focusedSurface && spreadRepeater.count > 0) {
++                spreadRepeater.itemAt(0).focus = true;
+             }
              spreadView.selectedIndex = -1;
@@ -258,6 +210,36 @@
+         }
+     }
++    Instantiator {
++        model: root.applicationManager
++        delegate: QtObject {
++            property var stateBinding: Binding {
++                readonly property bool isDash: model.application ? model.application.appId == "unity8-dash" : false
++                target: model.application
++                property: "requestedState"
++                value: (isDash && root.keepDashRunning)
++                           || (!root.suspended && model.application && priv.focusedAppId === model.application.appId)
++                       ? ApplicationInfoInterface.RequestedRunning
++                       : ApplicationInfoInterface.RequestedSuspended
++            }
++
++            property var lifecycleBinding: Binding {
++                target: model.application
++                property: "exemptFromLifecycle"
++                value: model.application
++                            ? (!model.application.isTouchApp || isExemptFromLifecycle(model.application.appId))
++                            : false
++            }
++        }
++    }
++
++    Binding {
++        target: MirFocusController
++        property: "focusedSurface"
++        value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null
++        when: root.parent && !spreadRepeater.startingUp
++    }
++
      Flickable {
          id: spreadView
          objectName: "spreadView"
@@ -308,13 +290,38 @@
          // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically
          // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger
          // the Flickable.boundsBehavior upon release).
--        onContentXChanged: { forceItToRemainStillIfBeingResized(); }
++        onContentXChanged: {
++            if (!undoContentXReset()) {
++                forceItToRemainStillIfBeingResized();
++            }
++        }
          onShiftChanged: { forceItToRemainStillIfBeingResized(); }
          function forceItToRemainStillIfBeingResized() {
              if (root.beingResized && contentX != -spreadView.shift) {
                  contentX = -spreadView.shift;
+             }
+         }
++        function undoContentXReset() {
++            if (contentWidth <= 0) {
++                contentWidthOnLastContentXChange = contentWidth;
++                lastContentX = contentX;
++                return false;
++            }
++
++            if (contentWidth !== contentWidthOnLastContentXChange
++                    && lastContentX === -shift && contentX === 0) {
++                // Flickable is resetting contentX because contentWidth has changed. Undo it.
++                contentX = -shift;
++                return true;
++            }
++
++            contentWidthOnLastContentXChange = contentWidth;
++            lastContentX = contentX;
++            return false;
++        }
++        property real contentWidthOnLastContentXChange: -1
++        property real lastContentX: 0
++        // </FIXME-contentX>
          Behavior on contentX {
              enabled: root.altTabPressed
@@ -377,7 +384,7 @@
                  snapAnimation.start();
                  return;
+             }
--            if (root.applicationManager.count <= index) {
++            if (topLevelSurfaceList.count <= index) {
                  // In case we're trying to snap to some non existing app, lets snap back to the first one
                  index = 0;
+             }
@@ -414,7 +421,8 @@
              ScriptAction {
                  script: {
                      if (spreadView.selectedIndex >= 0) {
--                        root.applicationManager.focusApplication(root.applicationManager.get(spreadView.selectedIndex).appId);
++                        var delegate = spreadRepeater.itemAt(spreadView.selectedIndex)
++                        delegate.focus = true;
                          spreadView.selectedIndex = -1;
                          spreadView.phase = 0;
@@ -429,7 +437,7 @@
              // This width controls how much the spread can be flicked left/right. It's composed of:
              //  tileDistance * app count (with a minimum of 3 apps, in order to also allow moving 1 and 2 apps a bit)
              //  + some constant value (still scales with the screen width) which looks good and somewhat fills the screen
--            width: Math.max(3, root.applicationManager.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5
++            width: Math.max(3, topLevelSurfaceList.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5
              height: parent.height
              Behavior on width {
                  enabled: spreadView.closingIndex >= 0
@@ -449,13 +457,30 @@
+                 }
+             }
--            Repeater {
++            TopLevelSurfaceRepeater {
                  id: spreadRepeater
                  objectName: "spreadRepeater"
--                model: root.applicationManager
++                model: topLevelSurfaceList
++
++                onItemRemoved: {
++                    // Unless we're closing the app ourselves in the spread,
++                    // lets make sure the spread doesn't mess up by the changing app list.
++                    if (spreadView.closingIndex == -1) {
++                        spreadView.phase = 0;
++                        spreadView.contentX = -spreadView.shift;
++                        focusTopMostApp();
++                    }
++                }
++                function focusTopMostApp() {
++                    if (spreadRepeater.count > 0) {
++                        var topmostDelegate = spreadRepeater.itemAt(0);
++                        topmostDelegate.focus = true;
++                    }
++                }
++
                  delegate: TransformedSpreadDelegate {
                      id: appDelegate
--                    objectName: "appDelegate" + index
++                    objectName: "spreadDelegate_" + model.id
                      startAngle: 45
                      endAngle: 5
                      startScale: root.startScale
@@ -467,28 +492,61 @@
                      selected: spreadView.selectedIndex == index
                      otherSelected: spreadView.selectedIndex >= 0 && !selected
                      interactive: !spreadView.interactive && spreadView.phase === 0
--                            && priv.fullyShowingFocusedApp && root.interactive && isFocused
++                            && priv.fullyShowingFocusedApp && root.interactive && focus
                      swipeToCloseEnabled: spreadView.interactive && root.interactive && !snapAnimation.running
                      maximizedAppTopMargin: root.maximizedAppTopMargin
                      dropShadow: spreadView.active || priv.focusedAppDelegateIsDislocated
                      focusFirstApp: root.focusFirstApp
                      highlightShown: root.altTabPressed && index === priv.highlightIndex
--                    readonly property bool isDash: model.appId == "unity8-dash"
--
--                    Binding {
--                        target: appDelegate.application
--                        property: "exemptFromLifecycle"
--                        value: !model.isTouchApp || isExemptFromLifecycle(model.appId)
--                    }
--
--                    Binding {
--                        target: appDelegate.application
--                        property: "requestedState"
--                        value: (isDash && root.keepDashRunning)
--                                   || (!root.suspended && appDelegate.focus)
--                               ? ApplicationInfoInterface.RequestedRunning
--                               : ApplicationInfoInterface.RequestedSuspended
++                    readonly property bool isDash: model.application.appId == "unity8-dash"
++
++                    Component.onCompleted: {
++                        // NB: We're differentiating if this delegate was created in response to a new entry in the model
++                        //     or if the Repeater is just populating itself with delegates to match the model it received.
++                        if (!spreadRepeater.startingUp) {
++                            // a top level window is always the focused one when it first appears, unfocusing
++                            // any preexisting one
++                            //
++                            // new items are appended and must be manually brought to front.
++                            // that's how it *must* be in order to get the animation for new
++                            // surfaces working
++                            claimFocus();
++                        }
++                    }
++
++                    onFocusChanged: {
++                        if (focus && !spreadRepeater.startingUp) {
++                            priv.focusedAppDelegate = appDelegate;
++                            // If we're orphan (!parent) it means this stage is no longer the current one
++                            // and will be deleted shortly. So we should no longer have a say over the model
++                            if (root.parent) {
++                                topLevelSurfaceList.raiseId(model.id);
++                            }
++                        }
++                    }
++                    function claimFocus() {
++                        if (spreadView.phase > 0) {
++                            spreadView.snapTo(model.index);
++                        } else {
++                            appDelegate.focus = true;
++                        }
++                    }
++                    Connections {
++                        target: model.surface
++                        onFocusRequested: claimFocus()
++                    }
++                    Connections {
++                        target: model.application
++                        onFocusRequested: {
++                            if (!model.surface) {
++                                // when an app has no surfaces, we assume there's only one entry representing it:
++                                // this delegate.
++                                claimFocus();
++                            } else {
++                                // if the application has surfaces, focus request should be at surface-level.
++                            }
++                        }
+                     }
                      z: isDash && !spreadView.active ? -1 : behavioredIndex
@@ -509,7 +567,8 @@
                          return spreadView.width + spreadIndex * spreadView.tileDistance;
+                     }
--                    application: root.applicationManager.get(index)
++                    application: model.application
++                    surface: model.surface
                      closeable: !isDash
                      property real behavioredIndex: index
@@ -593,11 +652,7 @@
                      onClicked: {
                          if (root.altTabEnabled && spreadView.phase == 2) {
--                            if (root.applicationManager.focusedApplicationId == root.applicationManager.get(index).appId) {
--                                spreadView.snapTo(index);
--                            } else {
--                                root.applicationManager.requestFocusApplication(root.applicationManager.get(index).appId);
--                            }
++                            spreadView.snapTo(index);
+                         }
+                     }
@@ -611,7 +666,15 @@
                      onClosed: {
                          spreadView.closingIndex = index;
--                        root.applicationManager.stopApplication(root.applicationManager.get(index).appId);
++                        if (appDelegate.surface) {
++                            appDelegate.surface.close();
++                        } else if (appDelegate.application) {
++                            root.applicationManager.stopApplication(appDelegate.application.appId);
++                        } else {
++                            // should never happen
++                            console.warn("Can't close topLevelSurfaceList entry as it has neither"
++                                         + " a surface nor an application");
++                        }
+                     }
                      Binding {
@@ -629,7 +692,7 @@
                      StagedFullscreenPolicy {
                          id: fullscreenPolicy
--                        application: appDelegate.application
++                        surface: model.surface
+                     }
                      Connections {
@@ -637,7 +700,7 @@
                          onStageAboutToBeUnloaded: fullscreenPolicy.active = false
+                     }
+                 }
--            }
++            } // Repeater {
+         }
+     }
 === added file 'qml/Stages/PromptSurfaceAnimations.qml'
 --- qml/Stages/PromptSurfaceAnimations.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/PromptSurfaceAnimations.qml	2016-04-20 17:09:16 +0000
@@ -0,0 +1,81 @@
++/*
++ * Copyright 2016 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program. If not, see <http://www.gnu.org/licenses/>.
++*/
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++
++StateGroup {
++    id: root
++    property var container
++    property var surfaceItem
++
++    states: [
++        State {
++            name: "blank"
++            when: !root.surfaceItem.surface
++        },
++        State {
++            name: "ready"
++            when: root.surfaceItem.surface && root.surfaceItem.live
++        },
++        State {
++            name: "zombie"
++            when: root.surfaceItem.surface && !root.surfaceItem.live
++        }
++    ]
++    transitions: [
++        Transition {
++            from: "*"; to: "zombie"
++            // Slide downwards until it's out of view, through the bottom of the window
++            SequentialAnimation {
++                // clip so we don't go out of parent's bounds during spread
++                PropertyAction { target: root.container.parent; property: "clip"; value: true }
++                UbuntuNumberAnimation { target: root.surfaceItem; property: "y"; to: root.container.height
++                                        duration: UbuntuAnimation.BriskDuration }
++                PropertyAction { target: root.surfaceItem; property: "visible"; value: false }
++                PropertyAction { target: container.parent; property: "clip"; value: false }
++                ScriptAction { script: {
++                    // Unity.Application can't destroy a zombie MirSurface if it's still being
++                    // referenced by a MirSurfaceItem.
++                    root.surfaceItem.surface = null;
++                } }
++            }
++        },
++        Transition {
++            from: "*"; to: "ready"
++            // Slide upwards into view, from the bottom of the window
++            SequentialAnimation {
++                // clip so we don't go out of parent's bounds during spread
++                PropertyAction { target: root.container.parent; property: "clip"; value: true }
++                ScriptAction { script: {
++                    root.surfaceItem.y = root.container.height;
++                    root.surfaceItem.visible = true;
++                } }
++                UbuntuNumberAnimation {
++                    target: root.surfaceItem; property: "y"; to: 0
++                    duration: UbuntuAnimation.BriskDuration
++                }
++                PropertyAction { target: container.parent; property: "clip"; value: false }
++            }
++        },
++        Transition {
++            from: "*"; to: "blank"
++            ScriptAction { script: {
++                root.surfaceItem.visible = false;
++            } }
++        }
++    ]
++}
 === modified file 'qml/Stages/SpreadDelegate.qml'
 --- qml/Stages/SpreadDelegate.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/SpreadDelegate.qml	2016-04-20 17:09:16 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright 2014-2015 Canonical Ltd.
++ * Copyright 2014-2016 Canonical Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
@@ -45,6 +45,7 @@
      property alias swipeToCloseEnabled: dragArea.enabled
      property bool closeable
      property alias application: appWindow.application
++    property alias surface: appWindow.surface
      property int shellOrientationAngle
      property int shellOrientation
      property QtObject orientations
@@ -250,7 +251,7 @@
+                     }
                      PropertyChanges {
                          target: appWindow
--                        surfaceOrientationAngle: orientationAngle
++                        surfaceOrientationAngle: appWindowWithShadow.orientationAngle
+                     }
                  },
                  State {
@@ -292,7 +293,7 @@
              ApplicationWindow {
                  id: appWindow
--                objectName: application ? "appWindow_" + application.appId : "appWindow_null"
++                objectName: "appWindow"
                  focus: true
                  anchors {
                      fill: parent
 === modified file 'qml/Stages/StagedFullscreenPolicy.qml'
 --- qml/Stages/StagedFullscreenPolicy.qml	2016-03-15 19:38:03 +0000
 +++ qml/Stages/StagedFullscreenPolicy.qml	2016-04-20 17:09:16 +0000
@@ -27,31 +27,29 @@
  // Chrome not set and state change to fulscreen -> client window stays "fullscreen"
  QtObject {
      property bool active: true
--    property QtObject application: null
--    readonly property var lastSurface: application && application.session ?
--                              application.session.lastSurface : null
--    onLastSurfaceChanged: {
--        if (!active || !lastSurface) return;
--        if (lastSurface.shellChrome === Mir.LowChrome) {
--            lastSurface.state = Mir.FullscreenState;
++    property var surface: null
++    onSurfaceChanged: {
++        if (!active || !surface) return;
++        if (surface.shellChrome === Mir.LowChrome) {
++            surface.state = Mir.FullscreenState;
+         }
+     }
      property var _connections: Connections {
--        target: lastSurface
++        target: surface
          onShellChromeChanged: {
--            if (!active || !lastSurface) return;
--            if (lastSurface.shellChrome === Mir.LowChrome) {
--                lastSurface.state = Mir.FullscreenState;
++            if (!active || !surface) return;
++            if (surface.shellChrome === Mir.LowChrome) {
++                surface.state = Mir.FullscreenState;
              } else {
--                lastSurface.state = Mir.RestoredState;
++                surface.state = Mir.RestoredState;
+             }
+         }
          onStateChanged: {
              if (!active) return;
--            if (lastSurface.state === Mir.RestoredState && lastSurface.shellChrome === Mir.LowChrome) {
--                lastSurface.state = Mir.FullscreenState;
++            if (surface.state === Mir.RestoredState && surface.shellChrome === Mir.LowChrome) {
++                surface.state = Mir.FullscreenState;
+             }
+         }
+     }
 === renamed file 'qml/Stages/SessionContainer.qml' => 'qml/Stages/SurfaceContainer.qml'
 --- qml/Stages/SessionContainer.qml	2016-02-03 13:46:18 +0000
 +++ qml/Stages/SurfaceContainer.qml	2016-04-20 17:09:16 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright 2014-2015 Canonical Ltd.
++ * Copyright 2014-2016 Canonical Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
@@ -15,61 +15,124 @@
  */
  import QtQuick 2.4
--import "Animations"
++import Ubuntu.Components 1.3
++import Ubuntu.Gestures 0.1 // For TouchGate
++import Utils 0.1 // for InputWatcher
++import Unity.Application 0.1 // for MirSurfaceItem
  FocusScope {
      id: root
--    objectName: "sessionContainer"
--    implicitWidth: _surfaceContainer.implicitWidth
--    implicitHeight: _surfaceContainer.implicitHeight
--    property QtObject session
--    readonly property var childSessions: session ? session.childSessions : null
--    readonly property alias surface: _surfaceContainer.surface
--    property alias interactive: _surfaceContainer.interactive
--    property alias surfaceOrientationAngle: _surfaceContainer.surfaceOrientationAngle
--    property alias resizeSurface: _surfaceContainer.resizeSurface
--
++    objectName: "surfaceContainer"
++
++    // Must be set from outside
++    property var surface: null
++
++    // Might be changed from outside
      property int requestedWidth: -1
      property int requestedHeight: -1
--
--    readonly property alias surfaceContainer: _surfaceContainer
--    SurfaceContainer {
--        id: _surfaceContainer
--        requestedWidth: root.requestedWidth
--        requestedHeight: root.requestedHeight
--        surface: session ? session.lastSurface : null
--    }
--
--    // SurfaceContainer size drives SessionContainer size
--    Binding {
--        target: root; property: "width"; value: _surfaceContainer.width
++    property bool interactive
++    property int surfaceOrientationAngle: 0
++    property bool resizeSurface: true
++    property bool inPromptSession: false
++
++    onSurfaceChanged: {
++        // Not a binding because animations might remove the surface from the surfaceItem
++        // programatically (in order to signal that a zombie surface is free for deletion),
++        // even though root.surface is still !null.
++        surfaceItem.surface = surface;
++    }
++
++    InputWatcher {
++        target: surfaceItem
++        onTargetPressedChanged: {
++            if (targetPressed && root.interactive) {
++                root.focus = true;
++                root.forceActiveFocus();
++            }
++        }
++    }
++
++    MirSurfaceItem {
++        id: surfaceItem
++        objectName: "surfaceItem"
++
++        fillMode: MirSurfaceItem.PadOrCrop
++        consumesInput: true
++
++        surfaceWidth: {
++            if (root.resizeSurface) {
++                if (root.requestedWidth >= 0) {
++                    return root.requestedWidth;
++                } else {
++                    return width;
++                }
++            } else {
++                return -1;
++            }
++        }
++
++        surfaceHeight: {
++            if (root.resizeSurface) {
++                if (root.requestedHeight >= 0) {
++                    return root.requestedHeight;
++                } else {
++                    return height;
++                }
++            } else {
++                return -1;
++            }
++        }
++
++        enabled: root.interactive
++        antialiasing: !root.interactive
++        orientationAngle: root.surfaceOrientationAngle
++    }
++
++    TouchGate {
++        targetItem: surfaceItem
++        anchors.fill: root
++        enabled: surfaceItem.enabled
++    }
++
++    // MirSurface size drives SurfaceContainer size
++    Binding {
++        target: surfaceItem; property: "width"; value: root.surface ? root.surface.size.width : 0
++        when: root.requestedWidth >= 0 && root.surface
++    }
++    Binding {
++        target: surfaceItem; property: "height"; value: root.surface ? root.surface.size.height : 0
++        when: root.requestedHeight >= 0 && root.surface
++    }
++    Binding {
++        target: root; property: "width"; value: surfaceItem.width
          when: root.requestedWidth >= 0
+     }
      Binding {
--        target: root; property: "height"; value: _surfaceContainer.height
++        target: root; property: "height"; value: surfaceItem.height
          when: root.requestedHeight >= 0
+     }
--    // SessionContainer size drives SurfaceContainer size
++    // SurfaceContainer size drives MirSurface size
      Binding {
--        target: _surfaceContainer; property: "width"; value: root.width
++        target: surfaceItem; property: "width"; value: root.width
          when: root.requestedWidth < 0
+     }
      Binding {
--        target: _surfaceContainer; property: "height"; value: root.height
++        target: surfaceItem; property: "height"; value: root.height
          when: root.requestedHeight < 0
+     }
      Repeater {
--        id: childSessionsRepeater
--        model: root.childSessions
++        id: childSurfacesRepeater
++        objectName: "childSurfacesRepeater"
++        model: root.surface ? root.surface.promptSurfaceList : null
          delegate: Loader {
              objectName: "childDelegate" + index
--            anchors.fill: surfaceContainer
++            anchors.fill: root
              // Only way to do recursive qml items.
--            source: Qt.resolvedUrl("SessionContainer.qml")
++            source: Qt.resolvedUrl("SurfaceContainer.qml")
              z: index
@@ -81,12 +144,12 @@
              Binding {
                  target: item; when: item
--                property: "interactive"; value: index == (childSessionsRepeater.count - 1) && root.interactive
++                property: "interactive"; value: index == (childSurfacesRepeater.count - 1) && root.interactive
+             }
              Binding {
                  target: item; when: item
--                property: "session"; value: modelData
++                property: "surface"; value: model.surface
+             }
              Binding {
@@ -98,79 +161,47 @@
                  target: item; when: item
                  property: "height"; value: root.height
+             }
--        }
--    }
--
--    states: [
--        State {
--            name: "rootSession"
--            when: root.session && !root.session.parentSession
--        },
--
--        State {
--            name: "childSession"
--            when: root.session && root.session.parentSession !== null && root.session.live
--                    && !root.session.lastSurface
--        },
--
--        State {
--            name: "childSessionReady"
--            when: root.session && root.session.parentSession !== null && root.session.live
--                    && root.session.lastSurface !== null
--        },
--
--        State {
--            name: "childSessionZombie"
--            when: root.session && root.session.parentSession !== null && !root.session.live
--        }
--    ]
--
--    transitions: [
--        Transition {
--            to: "childSessionReady"
--            ScriptAction { script: { if (!surfaceContainer.hadSurface) { animateIn(swipeFromBottom); } } }
--        },
--        Transition {
--            to: "childSessionZombie"
--            ScriptAction { script: { animateOut(); } }
--        }
--    ]
--
--    function animateIn(component) {
--        var animation = component.createObject(root, { "container": root, });
--        animation.start();
--
--        var tmp = d.animations;
--        tmp.push(animation);
--        d.animations = tmp;
--    }
--
--    function animateOut() {
--        if (d.animations.length > 0) {
--            var tmp = d.animations;
--            var popped = tmp.pop();
--            popped.completed.connect(function() { root.session.release(); } );
--            popped.end();
--            d.animations = tmp;
--        } else {
--            root.session.release();
--        }
--    }
--
--    Component {
--        id: swipeFromBottom
--        SwipeFromBottomAnimation {}
++
++            Binding {
++                target: item; when: item
++                property: "inPromptSession"; value: true
++            }
++        }
++    }
++
++    Loader {
++        id: animationsLoader
++        objectName: "animationsLoader"
++        active: root.surface
++        source: {
++            if (root.inPromptSession) {
++                return "PromptSurfaceAnimations.qml";
++            } else {
++                // Let ApplicationWindow do the animations
++                return "";
++            }
++        }
++        Binding {
++            target: animationsLoader.item
++            when: animationsLoader.item
++            property: "surfaceItem"
++            value: surfaceItem
++        }
++        Binding {
++            target: animationsLoader.item
++            when: animationsLoader.item
++            property: "container"
++            value: root
++        }
+     }
      QtObject {
          id: d
--        property var animations: []
--
          property var focusedChild: {
--            if (childSessionsRepeater.count == 0) {
--                return _surfaceContainer;
++            if (childSurfacesRepeater.count == 0) {
++                return surfaceItem;
              } else {
--                return childSessionsRepeater.itemAt(childSessionsRepeater.count - 1);
++                return childSurfacesRepeater.itemAt(childSurfacesRepeater.count - 1);
+             }
+         }
          onFocusedChildChanged: {
 === removed file 'qml/Stages/SurfaceContainer.qml'
 --- qml/Stages/SurfaceContainer.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/SurfaceContainer.qml	1970-01-01 00:00:00 +0000
@@ -1,154 +0,0 @@
--/*
-- * Copyright 2014-2015 Canonical Ltd.
-- *
-- * This program is free software; you can redistribute it and/or modify
-- * it under the terms of the GNU Lesser General Public License as published by
-- * the Free Software Foundation; version 3.
-- *
-- * This program is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- * GNU Lesser General Public License for more details.
-- *
-- * You should have received a copy of the GNU Lesser General Public License
-- * along with this program. If not, see <http://www.gnu.org/licenses/>.
--*/
--
--import QtQuick 2.4
--import Ubuntu.Components 1.3
--import Ubuntu.Gestures 0.1 // For TouchGate
--import Utils 0.1 // for InputWatcher
--import Unity.Application 0.1 // for MirSurfaceItem
--
--FocusScope {
--    id: root
--    objectName: "surfaceContainer"
--
--    property var surface: null
--    property bool hadSurface: false
--    property bool interactive
--    property int surfaceOrientationAngle: 0
--    property string name: surface ? surface.name : ""
--    property bool resizeSurface: true
--
--    property int requestedWidth: -1
--    property int requestedHeight: -1
--
--    onSurfaceChanged: {
--        if (surface) {
--            surfaceItem.surface = surface;
--            root.hadSurface = false;
--        }
--    }
--
--    InputWatcher {
--        target: surfaceItem
--        onTargetPressedChanged: {
--            if (targetPressed && root.interactive) {
--                root.focus = true;
--                root.forceActiveFocus();
--            }
--        }
--    }
--
--    MirSurfaceItem {
--        id: surfaceItem
--        objectName: "surfaceItem"
--
--        fillMode: MirSurfaceItem.PadOrCrop
--        consumesInput: true
--
--        surfaceWidth: {
--            if (root.resizeSurface) {
--                if (root.requestedWidth >= 0) {
--                    return root.requestedWidth;
--                } else {
--                    return width;
--                }
--            } else {
--                return -1;
--            }
--        }
--
--        surfaceHeight: {
--            if (root.resizeSurface) {
--                if (root.requestedHeight >= 0) {
--                    return root.requestedHeight;
--                } else {
--                    return height;
--                }
--            } else {
--                return -1;
--            }
--        }
--
--        enabled: root.interactive
--        focus: true
--        antialiasing: !root.interactive
--        orientationAngle: root.surfaceOrientationAngle
--    }
--
--    // MirSurface size drives SurfaceContainer size
--    Binding {
--        target: surfaceItem; property: "width"; value: root.surface ? root.surface.size.width : 0
--        when: root.requestedWidth >= 0 && root.surface
--    }
--    Binding {
--        target: surfaceItem; property: "height"; value: root.surface ? root.surface.size.height : 0
--        when: root.requestedHeight >= 0 && root.surface
--    }
--    Binding {
--        target: root; property: "width"; value: surfaceItem.width
--        when: root.requestedWidth >= 0
--    }
--    Binding {
--        target: root; property: "height"; value: surfaceItem.height
--        when: root.requestedHeight >= 0
--    }
--
--    // SurfaceContainer size drives MirSurface size
--    Binding {
--        target: surfaceItem; property: "width"; value: root.width
--        when: root.requestedWidth < 0
--    }
--    Binding {
--        target: surfaceItem; property: "height"; value: root.height
--        when: root.requestedHeight < 0
--    }
--
--
--    TouchGate {
--        objectName: "touchGate-"+name
--        targetItem: surfaceItem
--        anchors.fill: root
--        enabled: surfaceItem.enabled
--    }
--
--    states: [
--        State {
--            name: "zombie"
--            when: surfaceItem.surface && !surfaceItem.live
--        }
--    ]
--    transitions: [
--        Transition {
--            from: ""; to: "zombie"
--            SequentialAnimation {
--                UbuntuNumberAnimation { target: surfaceItem; property: "opacity"; to: 0.0
--                                        duration: UbuntuAnimation.BriskDuration }
--                PropertyAction { target: surfaceItem; property: "visible"; value: false }
--                ScriptAction { script: {
--                    surfaceItem.surface = null;
--                    root.hadSurface = true;
--                } }
--            }
--        },
--        Transition {
--            from: "zombie"; to: ""
--            ScriptAction { script: {
--                surfaceItem.opacity = 1.0;
--                surfaceItem.visible = true;
--            } }
--        }
--    ]
--}
 === modified file 'qml/Stages/TabletStage.qml'
 --- qml/Stages/TabletStage.qml	2016-04-20 17:09:15 +0000
 +++ qml/Stages/TabletStage.qml	2016-04-20 17:09:16 +0000
@@ -27,19 +27,24 @@
      objectName: "stages"
      anchors.fill: parent
++    // <tutorial-hacks> The Tutorial looks into our implementation details
      property alias sideStageVisible: spreadView.sideStageVisible
      property alias sideStageWidth: spreadView.sideStageWidth
++    // The stage the currently focused surface is in
++    property int stageFocusedSurface: priv.focusedAppDelegate ? priv.focusedAppDelegate.stage : ApplicationInfoInterface.MainStage
++    // </tutorial-hacks>
      // Functions to be called from outside
      function updateFocusedAppOrientation() {
--        var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);
--        if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {
--            spreadRepeater.itemAt(mainStageAppIndex).matchShellOrientation();
++        var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);
++
++        if (priv.mainStageItemId && mainStageIndex >= 0 && mainStageIndex < spreadRepeater.count) {
++            spreadRepeater.itemAt(mainStageIndex).matchShellOrientation();
+         }
          for (var i = 0; i < spreadRepeater.count; ++i) {
--            if (i === mainStageAppIndex) {
++            if (i === mainStageIndex) {
                  continue;
+             }
@@ -60,16 +65,14 @@
+         }
+     }
      function updateFocusedAppOrientationAnimated() {
--        var mainStageAppIndex = priv.indexOf(priv.mainStageAppId);
--        if (mainStageAppIndex >= 0 && mainStageAppIndex < spreadRepeater.count) {
--            spreadRepeater.itemAt(mainStageAppIndex).animateToShellOrientation();
++        var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);
++        if (priv.mainStageItemId && mainStageIndex >= 0 && mainStageIndex < spreadRepeater.count) {
++            spreadRepeater.itemAt(mainStageIndex).animateToShellOrientation();
+         }
--        if (priv.sideStageAppId) {
--            var sideStageAppIndex = priv.indexOf(priv.sideStageAppId);
--            if (sideStageAppIndex >= 0 && sideStageAppIndex < spreadRepeater.count) {
--                spreadRepeater.itemAt(sideStageAppIndex).matchShellOrientation();
--            }
++        var sideStageIndex = root.topLevelSurfaceList.indexForId(priv.sideStageItemId);
++        if (sideStageIndex >= 0 && sideStageIndex < spreadRepeater.count) {
++            spreadRepeater.itemAt(sideStageIndex).matchShellOrientation();
+         }
+     }
@@ -81,11 +84,20 @@
      orientationChangesEnabled: priv.mainAppOrientationChangesEnabled
++    mainApp: {
++        if (priv.mainStageItemId > 0) {
++            var index = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);
++            return root.topLevelSurfaceList.applicationAt(index);
++        } else {
++            return null;
++        }
++    }
++
      supportedOrientations: {
          if (mainApp) {
              var orientations = mainApp.supportedOrientations;
              orientations |= Qt.LandscapeOrientation | Qt.InvertedLandscapeOrientation;
--            if (priv.sideStageAppId && !spreadView.surfaceDragging) {
++            if (priv.sideStageItemId && !spreadView.surfaceDragging) {
                  // If we have a sidestage app, support Portrait orientation
                  // so that it will switch the sidestage app to mainstage on rotate
                  orientations |= Qt.PortraitOrientation|Qt.InvertedPortraitOrientation;
@@ -116,7 +128,7 @@
          if (inverseProgress == 0 && priv.oldInverseProgress > 0) {
              // left edge drag released. Minimum distance is given by design.
              if (priv.oldInverseProgress > units.gu(22)) {
--                ApplicationManager.requestFocusApplication("unity8-dash");
++                root.applicationManager.requestFocusApplication("unity8-dash");
+             }
+         }
          priv.oldInverseProgress = inverseProgress;
@@ -154,17 +166,51 @@
+         }
+     }
++    Connections {
++        target: root.topLevelSurfaceList
++        onListChanged: priv.updateMainAndSideStageIndexes()
++    }
++
      QtObject {
          id: priv
          objectName: "stagesPriv"
--        property string focusedAppId: ApplicationManager.focusedApplicationId
--        readonly property var focusedAppDelegate: {
--            var index = indexOf(focusedAppId);
--            return index >= 0 && index < spreadRepeater.count ? spreadRepeater.itemAt(index) : null
++        function updateMainAndSideStageIndexes() {
++            var choseMainStage = false;
++            var choseSideStage = false;
++
++            if (!root.topLevelSurfaceList)
++                return;
++
++            for (var i = 0; i < spreadRepeater.count && (!choseMainStage || !choseSideStage); ++i) {
++                var spreadDelegate = spreadRepeater.itemAt(i);
++                if (sideStage.shown && spreadDelegate.stage == ApplicationInfoInterface.SideStage
++                        && !choseSideStage) {
++                    priv.sideStageDelegate = spreadDelegate
++                    priv.sideStageItemId = root.topLevelSurfaceList.idAt(i);
++                    priv.sideStageAppId = root.topLevelSurfaceList.applicationAt(i).appId;
++                    choseSideStage = true;
++                } else if (!choseMainStage && spreadDelegate.stage == ApplicationInfoInterface.MainStage) {
++                    priv.mainStageDelegate = spreadDelegate;
++                    priv.mainStageItemId = root.topLevelSurfaceList.idAt(i);
++                    priv.mainStageAppId = root.topLevelSurfaceList.applicationAt(i).appId;
++                    choseMainStage = true;
++                }
++            }
++            if (!choseMainStage) {
++                priv.mainStageDelegate = null;
++                priv.mainStageItemId = 0;
++                priv.mainStageAppId = "";
++            }
++            if (!choseSideStage) {
++                priv.sideStageDelegate = null;
++                priv.sideStageItemId = 0;
++                priv.sideStageAppId = "";
++            }
+         }
--        property string oldFocusedAppId: ""
++        property var focusedAppDelegate: null
++
          property bool mainAppOrientationChangesEnabled: false
          property real landscapeHeight: root.orientations.native_ == Qt.LandscapeOrientation ?
@@ -173,36 +219,21 @@
          property bool shellIsLandscape: root.shellOrientation === Qt.LandscapeOrientation
                        || root.shellOrientation === Qt.InvertedLandscapeOrientation
--        property string mainStageAppId
--        property string sideStageAppId
--
--        // For convenience, keep properties of the first two apps in the model
--        property string appId0
--        property string appId1
++        property var mainStageDelegate: null
++        property var sideStageDelegate: null
++
++        property int mainStageItemId: 0
++        property int sideStageItemId: 0
++
++        property string mainStageAppId: ""
++        property string sideStageAppId: ""
          property int oldInverseProgress: 0
          property int highlightIndex: 0
--        onFocusedAppIdChanged: updateStageApps()
--
--        onFocusedAppDelegateChanged: {
--            if (focusedAppDelegate) {
--                focusedAppDelegate.focus = true;
--            }
--        }
--
          property bool focusedAppDelegateIsDislocated: focusedAppDelegate &&
                                                        (focusedAppDelegate.dragOffset !== 0 || focusedAppDelegate.xTranslateAnimating)
--        function indexOf(appId) {
--            for (var i = 0; i < ApplicationManager.count; i++) {
--                if (ApplicationManager.get(i).appId == appId) {
--                    return i;
--                }
--            }
--            return -1;
--        }
--
          function evaluateOneWayFlick(gesturePoints) {
              // Need to have at least 3 points to recognize it as a flick
              if (gesturePoints.length < 3) {
@@ -231,88 +262,45 @@
              spreadView.contentX = highlightIndex * spreadView.contentWidth / (spreadRepeater.count + 2)
+         }
--        function getTopApp(stage) {
--            for (var i = 0; i < ApplicationManager.count; i++) {
--                var app = ApplicationManager.get(i)
--                if (app.stage === stage) {
--                    return app;
--                }
--            }
--            return null;
--        }
--
--        function setAppStage(appId, stage, save) {
--            var app = ApplicationManager.findApplication(appId);
--            if (app) {
--                app.stage = stage;
--                if (save) {
--                    WindowStateStorage.saveStage(appId, stage);
--                }
--            }
--        }
--
--        function updateStageApps() {
--            var app = priv.getTopApp(ApplicationInfoInterface.MainStage);
--            priv.mainStageAppId = app ? app.appId : ""
--            root.mainApp = app;
--
--            if (sideStage.shown) {
--                app = priv.getTopApp(ApplicationInfoInterface.SideStage);
--                priv.sideStageAppId = app ? app.appId : ""
--            } else {
--                priv.sideStageAppId = "";
--            }
--
--            appId0 = ApplicationManager.count >= 1 ? ApplicationManager.get(0).appId : "";
--            appId1 = ApplicationManager.count > 1 ? ApplicationManager.get(1).appId : "";
--        }
--
          readonly property bool sideStageEnabled: root.shellOrientation == Qt.LandscapeOrientation ||
                                                   root.shellOrientation == Qt.InvertedLandscapeOrientation
--        Component.onCompleted: updateStageApps();
--    }
--
--    Connections {
--        target: ApplicationManager
--        onFocusRequested: {
--            if (spreadView.interactive) {
--                spreadView.snapTo(priv.indexOf(appId));
--            } else {
--                ApplicationManager.focusApplication(appId);
--            }
--        }
--
--        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) {
--                ApplicationManager.focusApplication("unity8-dash")
--            }
--            if (priv.sideStageAppId == appId) {
--                var app = priv.getTopApp(ApplicationInfoInterface.SideStage);
--                priv.sideStageAppId = app === null ? "" : app.appId;
--            }
--
--            if (ApplicationManager.count == 0) {
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--            } else if (spreadView.closingIndex == -1) {
--                // Unless we're closing the app ourselves in the spread,
--                // lets make sure the spread doesn't mess up by the changing app list.
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--
--                ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
--            }
--        }
++    }
++
++    Instantiator {
++        model: root.applicationManager
++        delegate: QtObject {
++            property var stateBinding: Binding {
++                readonly property bool isDash: model.application ? model.application.appId == "unity8-dash" : false
++                target: model.application
++                property: "requestedState"
++
++                // NB: the first application clause is just to ensure we never get warnings for trying to access
++                //     members of a null variable.
++                value: model.application &&
++                        (
++                          (isDash && root.keepDashRunning)
++                           || (!root.suspended && (model.application.appId === priv.mainStageAppId
++                                                   || model.application.appId === priv.sideStageAppId))
++                        )
++                       ? ApplicationInfoInterface.RequestedRunning
++                       : ApplicationInfoInterface.RequestedSuspended
++            }
++
++            property var lifecycleBinding: Binding {
++                target: model.application
++                property: "exemptFromLifecycle"
++                value: model.application
++                            ? (!model.application.isTouchApp || isExemptFromLifecycle(model.application.appId))
++                            : false
++            }
++        }
++    }
++
++    Binding {
++        target: MirFocusController
++        property: "focusedSurface"
++        value: priv.focusedAppDelegate ? priv.focusedAppDelegate.surface : null
++        when: root.parent && !spreadRepeater.startingUp
+     }
      Flickable {
@@ -363,16 +351,45 @@
          property int selectedIndex: -1
          property int draggedDelegateCount: 0
          property int closingIndex: -1
--        property var selectedApplication: selectedIndex !== -1 ? ApplicationManager.get(selectedIndex) : null
++        property var selectedDelegate: selectedIndex !== -1 ? spreadRepeater.itemAt(selectedIndex) : null
--        // FIXME: Workaround Flickable's not keepping its contentX still when resized
--        onContentXChanged: { forceItToRemainStillIfBeingResized(); }
++        // <FIXME-contentX> Workaround Flickable's behavior of bringing contentX back between valid boundaries
++        // when resized. The proper way to fix this is refactoring PhoneStage so that it doesn't
++        // rely on having Flickable.contentX keeping an out-of-bounds value when it's set programatically
++        // (as opposed to having contentX reaching an out-of-bounds value through dragging, which will trigger
++        // the Flickable.boundsBehavior upon release).
++        onContentXChanged: {
++            if (!undoContentXReset()) {
++                forceItToRemainStillIfBeingResized();
++            }
++        }
          onShiftChanged: { forceItToRemainStillIfBeingResized(); }
          function forceItToRemainStillIfBeingResized() {
--            if (root.beingResized && contentX != -shift) {
++            if (root.beingResized && contentX != -spreadView.shift) {
++                contentX = -spreadView.shift;
++            }
++        }
++        function undoContentXReset() {
++            if (contentWidth <= 0) {
++                contentWidthOnLastContentXChange = contentWidth;
++                lastContentX = contentX;
++                return false;
++            }
++
++            if (contentWidth != contentWidthOnLastContentXChange
++                    && lastContentX == -shift && contentX == 0) {
++                // Flickable is resetting contentX because contentWidth has changed. Undo it.
                  contentX = -shift;
++                return true;
+             }
++
++            contentWidthOnLastContentXChange = contentWidth;
++            lastContentX = contentX;
++            return false;
+         }
++        property real contentWidthOnLastContentXChange: -1
++        property real lastContentX: 0
++        // </FIXME-contentX>
          property bool animateX: true
          property bool beingResized: root.beingResized
@@ -385,31 +402,33 @@
+             }
+         }
--        property real sideStageDragProgress: sideStage.progress
--        property bool sideStageVisible: priv.sideStageAppId
          property real sideStageWidth: units.gu(40)
          property bool surfaceDragging: triGestureArea.recognisedDrag
--        // In case the ApplicationManager already holds an app when starting up we're missing animations
++        readonly property bool sideStageVisible: priv.sideStageItemId != 0
++
++        // In case 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: {
++            var mainStageIndex = priv.mainStageDelegate ? priv.mainStageDelegate.index : -1;
++            var sideStageIndex = priv.sideStageDelegate ? priv.sideStageDelegate.index : -1;
              switch (state) {
              case "main":
--                if (ApplicationManager.count > 1) {
++                if (root.topLevelSurfaceList.count > 1) {
                      return 1;
+                 }
                  return -1;
              case "mainAndOverlay":
--                if (ApplicationManager.count <= 2) {
++                if (root.topLevelSurfaceList.count <= 2) {
                      return -1;
+                 }
--                if (priv.appId0 == priv.mainStageAppId || priv.appId0 == priv.sideStageAppId) {
--                    if (priv.appId1 == priv.mainStageAppId || priv.appId1 == priv.sideStageAppId) {
++                if (mainStageIndex == 0 || sideStageIndex == 0) {
++                    if (mainStageIndex == 1 || sideStageIndex == 1) {
                          return 2;
+                     }
                      return 1;
@@ -420,7 +439,7 @@
+             }
              return -1;
+         }
--        property int nextZInStack: indexToZIndex(nextInStack)
++        property int nextZInStack
          states: [
              State {
@@ -440,13 +459,13 @@
+             }
+         ]
          state: {
--            if ((priv.mainStageAppId && !priv.sideStageAppId) || !priv.sideStageEnabled) {
++            if ((priv.mainStageItemId && !priv.sideStageItemId) || !priv.sideStageEnabled) {
                  return "main";
+             }
--            if (!priv.mainStageAppId && priv.sideStageAppId) {
++            if (!priv.mainStageItemId && priv.sideStageItemId) {
                  return "overlay";
+             }
--            if (priv.mainStageAppId && priv.sideStageAppId) {
++            if (priv.mainStageItemId && priv.sideStageItemId) {
                  return "mainAndOverlay";
+             }
              return "empty";
@@ -511,38 +530,41 @@
              // only shuffle when we've got a main and overlay
              if (state !== "mainAndOverlay") return index;
--            var app = ApplicationManager.get(index);
++            var app = root.topLevelSurfaceList.applicationAt(index);
              if (!app) {
                  return index;
+             }
++            var stage = spreadRepeater.itemAt(index) ? spreadRepeater.itemAt(index).stage : app.stage;
              // don't shuffle indexes greater than "actives or next"
              if (index > 2) return index;
--            if (app.appId === priv.mainStageAppId) {
++            var mainStageIndex = root.topLevelSurfaceList.indexForId(priv.mainStageItemId);
++
++            if (index == mainStageIndex) {
                  // Active main stage always at 0
                  return 0;
+             }
              if (spreadView.nextInStack > 0) {
--                var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);
++                var stageOfNextInStack = spreadRepeater.itemAt(spreadView.nextInStack).stage;
                  if (index === spreadView.nextInStack) {
                      // this is the next app in stack.
--                    if (app.stage ===  ApplicationInfoInterface.SideStage) {
++                    if (stage ===  ApplicationInfoInterface.SideStage) {
                          // if the next app in stack is a sidestage app, it must order on top of other side stage app
--                        return Math.min(2, ApplicationManager.count-1);
++                        return Math.min(2, root.topLevelSurfaceList.count-1);
+                     }
                      return 1;
+                 }
--                if (nextAppInStack.stage ===  ApplicationInfoInterface.SideStage) {
++                if (stageOfNextInStack === ApplicationInfoInterface.SideStage) {
                      // if the next app in stack is a sidestage app, it must order on top of other side stage app
                      return 1;
+                 }
--                return Math.min(2, ApplicationManager.count-1);
++                return Math.min(2, root.topLevelSurfaceList.count-1);
+             }
--            return Math.min(index+1, ApplicationManager.count-1);
++            return Math.min(index+1, root.topLevelSurfaceList.count-1);
+         }
          SequentialAnimation {
@@ -560,12 +582,13 @@
                  script: {
                      if (spreadView.selectedIndex >= 0) {
                          var newIndex = spreadView.selectedIndex;
--                        var application = ApplicationManager.get(newIndex);
--                        if (application.stage === ApplicationInfoInterface.SideStage) {
++                        var application = root.topLevelSurfaceList.applicationAt(newIndex);
++                        var spreadDelegate = spreadRepeater.itemAt(newIndex);
++                        if (spreadDelegate.stage === ApplicationInfoInterface.SideStage) {
                              sideStage.showNow();
+                         }
                          spreadView.selectedIndex = -1;
--                        ApplicationManager.focusApplication(application.appId);
++                        spreadDelegate.focus = true;
                          spreadView.phase = 0;
                          spreadView.contentX = -spreadView.shift;
+                     }
@@ -581,7 +604,7 @@
          MouseArea {
              id: spreadRow
              x: spreadView.contentX
--            width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)
++            width: spreadView.width + Math.max(spreadView.width, root.topLevelSurfaceList.count * spreadView.tileDistance)
              height: root.height
              onClicked: {
@@ -599,8 +622,8 @@
                  enabled: priv.sideStageEnabled
                  onDropped: {
--                    priv.setAppStage(drag.source.appId, ApplicationInfoInterface.MainStage, true);
--                    ApplicationManager.focusApplication(drag.source.appId);
++                    drop.source.spreadDelegate.stage = ApplicationInfoInterface.MainStage;
++                    drop.source.spreadDelegate.focus = true;
+                 }
                  keys: "SideStage"
+             }
@@ -611,12 +634,12 @@
                  height: priv.landscapeHeight
                  x: spreadView.width - width
                  z: {
--                    if (!priv.mainStageAppId) return 0;
--
--                    if (priv.sideStageAppId && spreadView.nextInStack > 0) {
--                        var nextAppInStack = ApplicationManager.get(spreadView.nextInStack);
--
--                        if (nextAppInStack.stage ===  ApplicationInfoInterface.MainStage) {
++                    if (!priv.mainStageItemId) return 0;
++
++                    if (priv.sideStageItemId && spreadView.nextInStack > 0) {
++                        var nextDelegateInStack = spreadRepeater.itemAt(spreadView.nextInStack);
++
++                        if (nextDelegateInStack.stage ===  ApplicationInfoInterface.MainStage) {
                              // if the next app in stack is a main stage app, put the sidestage on top of it.
                              return 2;
+                         }
@@ -631,12 +654,11 @@
                  Behavior on opacity { UbuntuNumberAnimation {} }
                  onShownChanged: {
--                    if (!shown && ApplicationManager.focusedApplicationId == priv.sideStageAppId) {
--                        ApplicationManager.requestFocusApplication(priv.mainStageAppId);
--                    }
--                    priv.updateStageApps();
--                    if (shown && priv.sideStageAppId) {
--                        ApplicationManager.requestFocusApplication(priv.sideStageAppId);
++                    if (!shown && priv.sideStageDelegate && priv.focusedAppDelegate === priv.sideStageDelegate
++                            && priv.mainStageDelegate) {
++                        priv.mainStageDelegate.focus = true;
++                    } else if (shown && priv.sideStageDelegate) {
++                        priv.sideStageDelegate.focus = true;
+                     }
+                 }
@@ -655,8 +677,8 @@
+                     }
                      onDropped: {
                          if (drop.keys == "MainStage") {
--                            priv.setAppStage(drop.source.appId, ApplicationInfoInterface.SideStage, true);
--                            ApplicationManager.requestFocusApplication(drop.source.appId);
++                            drop.source.spreadDelegate.stage = ApplicationInfoInterface.SideStage;
++                            drop.source.spreadDelegate.focus = true;
+                         }
+                     }
                      drag {
@@ -669,41 +691,102 @@
+                 }
+             }
--            Repeater {
++            TopLevelSurfaceRepeater {
                  id: spreadRepeater
                  objectName: "spreadRepeater"
--                model: ApplicationManager
++                model: root.topLevelSurfaceList
++
++                onItemAdded: {
++                    priv.updateMainAndSideStageIndexes();
++                    if (spreadView.phase == 2) {
++                        spreadView.snapTo(index);
++                    }
++                }
++
++                onItemRemoved: {
++                    priv.updateMainAndSideStageIndexes();
++                    // Unless we're closing the app ourselves in the spread,
++                    // lets make sure the spread doesn't mess up by the changing app list.
++                    if (spreadView.closingIndex == -1) {
++                        spreadView.phase = 0;
++                        spreadView.contentX = -spreadView.shift;
++                        focusTopMostApp();
++                    }
++                }
++                function focusTopMostApp() {
++                    if (spreadRepeater.count > 0) {
++                        var topmostDelegate = spreadRepeater.itemAt(0);
++                        topmostDelegate.focus = true;
++                    }
++                }
                  delegate: TransformedTabletSpreadDelegate {
                      id: spreadTile
--                    objectName: model.appId ? "tabletSpreadDelegate_" + model.appId
--                                            : "tabletSpreadDelegate_null";
++                    objectName: "spreadDelegate_" + model.id
++
++                    readonly property int index: model.index
                      width: spreadView.width
                      height: spreadView.height
--                    active: appId == priv.mainStageAppId || appId == priv.sideStageAppId
++                    active: model.id == priv.mainStageItemId || model.id == priv.sideStageItemId
                      zIndex: selected && stage == ApplicationInfoInterface.MainStage ? 0 : spreadView.indexToZIndex(index)
++                    onZIndexChanged: {
++                        if (spreadView.nextInStack == model.index) {
++                            spreadView.nextZInStack = zIndex;
++                        }
++                    }
                      selected: spreadView.selectedIndex == index
                      otherSelected: spreadView.selectedIndex >= 0 && !selected
--                    isInSideStage: priv.sideStageAppId === appId
++                    isInSideStage: priv.sideStageItemId == model.id
                      interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive
                      swipeToCloseEnabled: spreadView.interactive && !snapAnimation.running
                      maximizedAppTopMargin: root.maximizedAppTopMargin
--                    dragOffset: !isDash && appId == priv.mainStageAppId && root.inverseProgress > 0 && spreadView.phase === 0 ? root.inverseProgress : 0
--                    application: ApplicationManager.get(index)
++                    dragOffset: !isDash && model.id == priv.mainStageItemId && root.inverseProgress > 0
++                            && spreadView.phase === 0 ? root.inverseProgress : 0
++                    application: model.application
++                    surface: model.surface
                      closeable: !isDash
                      highlightShown: root.altTabPressed && priv.highlightIndex == zIndex
--                    readonly property bool wantsMainStage: model.stage == ApplicationInfoInterface.MainStage
--
--                    readonly property string appId: model.appId
--                    readonly property bool isDash: model.appId == "unity8-dash"
--
--                    stage: model.stage
++                    readonly property bool wantsMainStage: stage == ApplicationInfoInterface.MainStage
++
++                    readonly property bool isDash: model.application.appId == "unity8-dash"
++
++                    onFocusChanged: {
++                        if (focus && !spreadRepeater.startingUp) {
++                            priv.focusedAppDelegate = spreadTile;
++                            root.topLevelSurfaceList.raiseId(model.id);
++                        }
++                        if (focus && priv.sideStageEnabled && stage === ApplicationInfoInterface.SideStage) {
++                            sideStage.show();
++                        }
++                    }
++                    Connections {
++                        target: model.surface
++                        onFocusRequested: spreadTile.focus = true;
++                    }
++                    Connections {
++                        target: model.application
++                        onFocusRequested: {
++                            if (!model.surface) {
++                                // when an app has no surfaces, we assume there's only one entry representing it:
++                                // this delegate.
++                                spreadTile.focus = true;
++                            } else {
++                                // if the application has surfaces, focus request should be at surface-level.
++                            }
++                        }
++                    }
++
                      fullscreen: {
--                        if (mainApp && stage === ApplicationInfoInterface.SideStage) {
--                            return mainApp.fullscreen;
++                        if (priv.mainStageDelegate && stage === ApplicationInfoInterface.SideStage) {
++                            return priv.mainStageDelegate.fullscreen;
++                        } else if (surface) {
++                            return surface.state === Mir.FullscreenState;
++                        } else if (application) {
++                            return application.fullscreen;
++                        } else {
++                            return false;
+                         }
--                        return application ? application.fullscreen : false;
+                     }
                      supportedOrientations: {
@@ -724,23 +807,6 @@
+                         }
+                     }
--
--                    Binding {
--                        target: spreadTile.application
--                        property: "exemptFromLifecycle"
--                        value: !model.isTouchApp || isExemptFromLifecycle(model.appId)
--                    }
--
--                    Binding {
--                        target: spreadTile.application
--                        property: "requestedState"
--                        value: (isDash && root.keepDashRunning)
--                                   || (!root.suspended && (model.appId == priv.mainStageAppId
--                                                           || model.appId == priv.sideStageAppId))
--                               ? ApplicationInfoInterface.RequestedRunning
--                               : ApplicationInfoInterface.RequestedSuspended
--                    }
--
                      // FIXME: A regular binding doesn't update any more after closing an app.
                      // Using a Binding for now.
                      Binding {
@@ -760,34 +826,33 @@
                          onSideStageEnabledChanged: refreshStage()
+                     }
++                    property bool _constructing: true;
++                    onStageChanged: {
++                        if (!_constructing) {
++                            priv.updateMainAndSideStageIndexes();
++                        }
++                    }
++
                      Component.onCompleted: {
--                        refreshStage()
--                        stageChanged.connect(priv.updateStageApps);
++                        // a top level window is always the focused one when it first appears, unfocusing
++                        // any preexisting one
++                        focus = true;
++                        refreshStage();
++                        _constructing = false;
++                    }
++                    Component.onDestruction: {
++                        WindowStateStorage.saveStage(model.application.appId, stage);
+                     }
                      function refreshStage() {
--                        var stage = ApplicationInfoInterface.MainStage;
++                        var newStage = ApplicationInfoInterface.MainStage;
                          if (priv.sideStageEnabled) {
                              if (application && application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {
--                                stage = WindowStateStorage.getStage(appId);
++                                newStage = WindowStateStorage.getStage(application.appId);
+                             }
+                         }
--                        if (model.stage !== stage) {
--                            priv.setAppStage(appId, stage, false);
--                        }
--                    }
--
--                    // This is required because none of the bindings are triggered in some cases:
--                    // When an app is closed, it might happen that ApplicationManager.get(nextInStack)
--                    // returns a different app even though the nextInStackIndex and all the related
--                    // bindings (index, mainStageApp, sideStageApp, etc) don't change. Let's force a
--                    // binding update in that case.
--                    Connections {
--                        target: ApplicationManager
--                        onApplicationRemoved: spreadTile.z = Qt.binding(function() {
--                            return spreadView.indexToZIndex(index);
--                        })
++                        stage = newStage;
+                     }
                      progress: {
@@ -873,13 +938,10 @@
                                      script: {
                                          // rotate immediately.
                                          spreadTile.matchShellOrientation();
--                                        if (ApplicationManager.focusedApplicationId === spreadTile.appId &&
++                                        if (priv.focusedAppDelegate === spreadTile &&
                                                  priv.sideStageEnabled && !sideStage.shown) {
                                              // Sidestage was focused, so show the side stage.
                                              sideStage.show();
--                                        // if we've switched to a main app which doesnt support portrait, hide the side stage.
--                                        } else if (mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {
--                                            sideStage.hideNow();
+                                         }
+                                     }
+                                 }
@@ -890,10 +952,10 @@
                              SequentialAnimation {
                                  ScriptAction {
                                      script: {
--                                        if (priv.sideStageAppId === spreadTile.appId &&
++                                        if (priv.sideStageDelegate === spreadTile &&
                                                  mainApp && (mainApp.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) == 0) {
                                              // The mainstage app did not natively support portrait orientation, so focus the sidestage.
--                                            ApplicationManager.requestFocusApplication(spreadTile.appId);
++                                            spreadTile.focus = true;
+                                         }
+                                     }
+                                 }
@@ -922,28 +984,26 @@
                      onClosed: {
                          spreadView.closingIndex = index;
--                        ApplicationManager.stopApplication(ApplicationManager.get(index).appId);
--                    }
--
--                    onFocusChanged: {
--                        if (focus && ApplicationManager.focusedApplicationId !== appId) {
--                            ApplicationManager.focusApplication(appId);
--                        }
--
--                        if (focus && priv.sideStageEnabled && stage === ApplicationInfoInterface.SideStage) {
--                            sideStage.show();
++                        if (spreadTile.surface) {
++                            spreadTile.surface.close();
++                        } else if (spreadTile.application) {
++                            root.applicationManager.stopApplication(spreadTile.application.appId);
++                        } else {
++                            // should never happen
++                            console.warn("Can't close topLevelSurfaceList entry as it has neither"
++                                         + " a surface nor an application");
+                         }
+                     }
                      Binding {
                          target: root
--                        when: model.appId == priv.mainStageAppId
++                        when: model.id == priv.mainStageItemId
                          property: "mainAppWindowOrientationAngle"
                          value: appWindowOrientationAngle
+                     }
                      Binding {
                          target: priv
--                        when: model.appId == priv.mainStageAppId
++                        when: model.id == priv.mainStageItemId
                          property: "mainAppOrientationChangesEnabled"
                          value: orientationChangesEnabled
+                     }
@@ -957,7 +1017,7 @@
                      StagedFullscreenPolicy {
                          id: fullscreenPolicy
--                        application: spreadTile.application
++                        surface: model.surface
+                     }
                      Connections {
                          target: root
@@ -973,17 +1033,19 @@
          anchors.fill: parent
          enabled: priv.sideStageEnabled && !spreadView.active
          property var dragObject: null
--        property string appId: ""
++
++        property Item spreadDelegate
++
          dragComponent: dragComponent
--        dragComponentProperties: { "appId": appId }
++        dragComponentProperties: { "spreadDelegate": spreadDelegate }
          onPressed: {
--            function matchDelegate(obj) { return String(obj.objectName).indexOf("tabletSpreadDelegate") >= 0; }
++            function matchDelegate(obj) { return String(obj.objectName).indexOf("spreadDelegate") >= 0; }
              var delegateAtCenter = Functions.itemAt(spreadRow, x, y, matchDelegate);
              if (!delegateAtCenter) return;
--            appId = delegateAtCenter.appId;
++            spreadDelegate = delegateAtCenter;
+         }
          onClicked: {
@@ -1003,11 +1065,11 @@
          Component {
              id: dragComponent
--            SessionContainer {
--                property string appId: ""
--                property var application: ApplicationManager.findApplication(appId)
--
--                session: application ? application.session : null
++            SurfaceContainer {
++                property Item spreadDelegate
++
++                surface: spreadDelegate ? spreadDelegate.surface : null
++
                  interactive: false
                  resizeSurface: false
                  focus: false
@@ -1019,10 +1081,11 @@
                  Drag.hotSpot.y: height/2
                  // only accept opposite stage.
                  Drag.keys: {
--                    if (!application) return "Disabled";
++                    if (!surface) return "Disabled";
--                    if (application.stage === ApplicationInfo.MainStage) {
--                        if (application.supportedOrientations & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {
++                    if (spreadDelegate.stage === ApplicationInfo.MainStage) {
++                        if (spreadDelegate.application.supportedOrientations
++                                & (Qt.PortraitOrientation|Qt.InvertedPortraitOrientation)) {
                              return "MainStage";
+                         }
                          return "Disabled";
 === added file 'qml/Stages/TopLevelSurfaceRepeater.qml'
 --- qml/Stages/TopLevelSurfaceRepeater.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/TopLevelSurfaceRepeater.qml	2016-04-20 17:09:16 +0000
@@ -0,0 +1,52 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++
++Repeater {
++    id: root
++    // FIXME: This is a hack around us not knowing whether the Repeater has finished creating its
++    // delegates on start up.
++    // This is a problem when the stage gets a TopLevelSurfaceList already populated with several
++    // rows.
++    property bool startingUp: true
++    onStartingUpChanged: {
++        if (!startingUp) {
++            // the top-most surface must be the focused one.
++            var topmostDelegate = itemAt(0);
++            topmostDelegate.focus = true;
++        }
++    }
++
++    onItemAdded: {
++        if (startingUp) {
++            checkIfStillStartingUp();
++        }
++    }
++
++    function checkIfStillStartingUp() {
++        var i = 0;
++        var missingDelegate = false;
++        for (i = 0; i < model.count && !missingDelegate; ++i) {
++            if (!itemAt(i)) {
++                missingDelegate = true;
++            }
++        }
++        if (!missingDelegate) {
++            startingUp = false;
++        }
++    }
++}
 === modified file 'qml/Stages/TransformedSpreadDelegate.qml'
 --- qml/Stages/TransformedSpreadDelegate.qml	2015-07-15 15:07:19 +0000
 +++ qml/Stages/TransformedSpreadDelegate.qml	2016-04-20 17:09:16 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright 2014 Canonical Ltd.
++ * Copyright 2014,2016 Canonical Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
@@ -312,7 +312,7 @@
          // non-fullscreen window when they're stacked on top of each other on the
          // far left of the spread.
          Translate {
--            y: !fullscreen && appWindowRotation === 180
++            y: !root.fullscreen && appWindowRotation === 180
                     ? priv.topMarginProgress * maximizedAppTopMargin
                     : 0
          },
@@ -326,7 +326,7 @@
                  switch (appWindowRotation) {
                  case 90:
                  case 270:
--                    if (fullscreen) {
++                    if (root.fullscreen) {
                          return 1;
                      } else {
                          return 1 + priv.topMarginProgress * maximizedAppTopMargin / spreadView.width;
@@ -340,7 +340,7 @@
              yScale: {
                  switch (appWindowRotation) {
                  case 0:
--                    if (fullscreen) {
++                    if (root.fullscreen) {
                          return 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height;
                      } else {
                          return 1;
 === modified file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
 --- qml/Stages/TransformedTabletSpreadDelegate.qml	2016-03-11 20:18:12 +0000
 +++ qml/Stages/TransformedTabletSpreadDelegate.qml	2016-04-20 17:09:16 +0000
@@ -31,7 +31,6 @@
      // Set this to true when this tile a currently active on either the MS or the SS.
      property bool active: false
--    property int stage
      property int zIndex
      property real progress: 0
      property real animatedProgress: 0
@@ -48,13 +47,15 @@
      property bool isInSideStage: false
++    property int stage: ApplicationInfoInterface.MainStage
++
      property int dragOffset: 0
      readonly property alias xTranslateAnimating: xTranslateAnimation.running
      readonly property bool offScreen: priv.xTranslate >= 0
      dropShadow: spreadView.active ||
                  (active
--                 && (stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)
++                 && (root.stage == ApplicationInfoInterface.MainStage || !priv.shellIsLandscape)
                   && priv.xTranslate != 0)
      onSelectedChanged: {
@@ -90,7 +91,7 @@
          id: priv
          // true if this is the next tile on the stack that comes in when dragging from the right
--        property bool nextInStack: spreadView.nextZInStack == zIndex
++        property bool nextInStack: spreadView.nextInStack == model.index
          // true if the next tile in the stack is the nextInStack one. This one will be moved a bit to the left
          property bool movedActive: spreadView.nextZInStack == zIndex + 1
          property real animatedEndDistance: linearAnimation(0, 2, root.endDistance, 0, root.progress)
@@ -142,7 +143,7 @@
          Behavior on xTranslate {
              enabled: !spreadView.active &&
                       !snapAnimation.running &&
--                     model.appId !== "unity8-dash" &&
++                     root.application.appId !== "unity8-dash" &&
                       spreadView.animateX &&
                       !spreadView.beingResized &&
                       priv.state !== "sideStage"
@@ -156,8 +157,9 @@
              var newTranslate = 0;
              // selected app or opposite stage active app.
--            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
--                if (stage == ApplicationInfoInterface.MainStage) {
++            if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate
++                        && spreadView.selectedDelegate.stage !== root.stage)) {
++                if (root.stage == ApplicationInfoInterface.MainStage) {
                      return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.width, root.progress);
                  } else {
                      return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.sideStageWidth, root.progress);
@@ -168,8 +170,8 @@
              // The tile should move a bit to the left if a new one comes on top of it, but not for the Side Stage and not
              // when we're only dragging the side stage in on top of a main stage app
--            var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && stage === ApplicationInfoInterface.MainStage &&
--                    ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;
++            var shouldMoveAway = spreadView.nextInStack >= 0 && priv.movedActive && root.stage === ApplicationInfoInterface.MainStage &&
++                    topLevelSurfaceList.applicationAt(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;
              if (active) {
                  newTranslate -= root.width
@@ -178,7 +180,7 @@
                      newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);
+                 }
                  newTranslate += root.dragOffset;
--            } else if (!spreadView.active && model.appId == "unity8-dash") {
++            } else if (!spreadView.active && root.application.appId == "unity8-dash") {
                  newTranslate -= root.width;
+             }
@@ -190,14 +192,14 @@
              if (spreadView.phase == 0) {
                  if (nextInStack) {
--                    if (stage == ApplicationInfoInterface.MainStage) {
++                    if (root.stage == ApplicationInfoInterface.MainStage) {
                          if (spreadView.sideStageVisible && root.progress > 0) {
                              // Move it so it appears from behind the side stage immediately
                              newTranslate += -spreadView.sideStageWidth;
+                         }
+                     }
--                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                    if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                          // This is when we only drag the side stage in, without rotation or snapping
                          newTranslate = linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth, root.animatedProgress);
                      } else {
@@ -210,7 +212,7 @@
              if (spreadView.phase == 1) {
                  if (nextInStack) {
--                    if (stage == ApplicationInfoInterface.MainStage) {
++                    if (root.stage == ApplicationInfoInterface.MainStage) {
                          var startValue = -spreadView.sideStageWidth * spreadView.snapPosition + (spreadView.sideStageVisible ? -spreadView.sideStageWidth : 0);
                          newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startValue, priv.phase2StartTranslate, root.animatedProgress);
                      } else {
@@ -250,7 +252,8 @@
+             }
              // selected app or opposite stage active app.
--            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
++            if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate
++                        && spreadView.selectedDelegate.stage !== root.stage)) {
                  return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);
              } else if (otherSelected) {
                  return selectedScale;
@@ -258,7 +261,7 @@
              if (spreadView.phase == 0) {
                  if (nextInStack) {
--                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                    if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                          return 1;
                      } else {
                          var targetScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
@@ -272,7 +275,7 @@
              if (spreadView.phase == 1) {
                  if (nextInStack) {
                      var startScale = 1;
--                    if (stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {
++                    if (root.stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {
                          startScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
+                     }
                      return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startScale, priv.phase2StartScale, root.animatedProgress);
@@ -295,7 +298,8 @@
+             }
              // selected app or opposite stage active app.
--            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
++            if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate
++                        && spreadView.selectedDelegate.stage !== root.stage)) {
                  return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);
              } else if (otherSelected) {
                  return selectedAngle;
@@ -304,12 +308,12 @@
              // The tile should rotate a bit when another one comes on top, but not when only dragging the side stage in
              var shouldMoveAway = spreadView.nextInStack == -1 ||
                      spreadView.nextInStack >= 0 && priv.movedActive &&
--                    (ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||
--                     stage == ApplicationInfoInterface.SideStage);
++                    (topLevelSurfaceList.applicationAt(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||
++                     root.stage == ApplicationInfoInterface.SideStage);
              if (spreadView.phase == 0) {
                  if (nextInStack) {
--                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                    if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                          return 0;
                      } else {
                          return linearAnimation(0, spreadView.positionMarker2, root.startAngle, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);
@@ -321,7 +325,7 @@
+             }
              if (spreadView.phase == 1) {
                  if (nextInStack) {
--                    if (stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                    if (root.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
                          return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, 0, priv.phase2StartAngle, root.animatedProgress);
                      } else {
                          return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, root.startAngle * (1-spreadView.snapPosition), priv.phase2StartAngle, root.animatedProgress);
@@ -345,7 +349,8 @@
              if (root.isSelected) return 1;
              if (otherSelected) {
--                if (root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage) {
++                if (root.active && spreadView.selectedDelegate
++                        && spreadView.selectedDelegate.stage !== root.stage) {
                      return 1;
+                 }
                  return linearAnimation(selectedProgress, negativeProgress, selectedOpacity, 0, root.progress);
@@ -355,7 +360,8 @@
          property real topMarginProgress: {
              // selected app or opposite stage active app.
--            if (isSelected || (otherSelected && root.active && spreadView.selectedApplication && spreadView.selectedApplication.stage !== stage)) {
++            if (isSelected || (otherSelected && root.active && spreadView.selectedDelegate
++                        && spreadView.selectedDelegate.stage !== root.stage)) {
                  return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);
+             }
@@ -379,7 +385,7 @@
                  when: root.isInSideStage && spreadView.shiftedContentX == 0 && spreadView.phase == 0
                  PropertyChanges {
                      target: priv;
--                    xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * (1-spreadView.sideStageDragProgress)
++                    xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * (1-sideStage.progress)
+                 }
+             }
+         ]
 === modified file 'qml/Stages/WindowedFullscreenPolicy.qml'
 --- qml/Stages/WindowedFullscreenPolicy.qml	2016-03-15 19:38:03 +0000
 +++ qml/Stages/WindowedFullscreenPolicy.qml	2016-04-20 17:09:16 +0000
@@ -23,19 +23,17 @@
  // state of the window is returned to restored.
  QtObject {
      property bool active: true
--    property QtObject application: null
++    property QtObject surface: null
--    readonly property var lastSurface: application && application.session ?
--                                      application.session.lastSurface : null
      property bool _firstTimeSurface: true
--    onLastSurfaceChanged: {
--        if (!active || !lastSurface) return;
++    onSurfaceChanged: {
++        if (!active || !surface) return;
          if (!_firstTimeSurface) return;
          _firstTimeSurface = false;
--        if (lastSurface.state === Mir.FullscreenState && lastSurface.shellChrome === Mir.LowChrome) {
--            lastSurface.state = Mir.RestoredState;
++        if (surface.state === Mir.FullscreenState && surface.shellChrome === Mir.LowChrome) {
++            surface.state = Mir.RestoredState;
+         }
+     }
+ }
 === modified file 'qml/Tutorial/TutorialBottom.qml'
 --- qml/Tutorial/TutorialBottom.qml	2016-03-16 15:08:49 +0000
 +++ qml/Tutorial/TutorialBottom.qml	2016-04-20 17:09:16 +0000
@@ -47,7 +47,7 @@
      readonly property real sideStageWidth: root.usageScenario === "tablet" && stage.sideStageVisible ?
                                             stage.sideStageWidth : 0
      readonly property bool isMainStageApp: usageScenario !== "tablet" ||
--                                           application.stage === ApplicationInfoInterface.MainStage
++                                           stage.stageFocusedSurface === ApplicationInfoInterface.MainStage
      readonly property real dragAreaHeight: units.gu(3) // based on PageWithBottomEdge.qml
      readonly property real targetDistance: height * 0.2 + dragAreaHeight // based on PageWithBottomEdge.qml
 === modified file 'tests/mocks/Unity/Application/ApplicationInfo.cpp'
 --- tests/mocks/Unity/Application/ApplicationInfo.cpp	2016-03-16 12:29:44 +0000
 +++ tests/mocks/Unity/Application/ApplicationInfo.cpp	2016-04-20 17:09:16 +0000
@@ -16,8 +16,7 @@
  #include "ApplicationInfo.h"
  #include "MirSurface.h"
--#include "Session.h"
--#include "SessionManager.h"
++#include "SurfaceManager.h"
  #include <paths.h>
@@ -25,97 +24,114 @@
  #include <QQuickItem>
  #include <QQuickView>
  #include <QQmlComponent>
--#include <QTimer>
++
++#define APPLICATION_DEBUG 0
++
++#if APPLICATION_DEBUG
++#define DEBUG_MSG(params) qDebug().nospace() << "Application["<<appId()<<"]::" << __func__  << " " << params
++
++QString stateToStr(ApplicationInfo::State state)
++{
++    switch (state) {
++    case ApplicationInfo::Starting:
++        return "starting";
++    case ApplicationInfo::Running:
++        return "running";
++    case ApplicationInfo::Suspended:
++        return "suspended";
++    case ApplicationInfo::Stopped:
++        return "stopped";
++    default:
++        return "???";
++    };
++}
++
++#else
++#define DEBUG_MSG(params) ((void)0)
++#endif
++
++#define WARNING_MSG(params) qWarning().nospace() << "Application["<<appId()<<"]::" << __func__  << " " << params
  ApplicationInfo::ApplicationInfo(const QString &appId, QObject *parent)
      : ApplicationInfoInterface(appId, parent)
      , m_appId(appId)
--    , m_stage(MainStage)
--    , m_state(Stopped)
--    , m_focused(false)
--    , m_fullscreen(false)
--    , m_session(0)
--    , m_supportedOrientations(Qt::PortraitOrientation |
--            Qt::LandscapeOrientation |
--            Qt::InvertedPortraitOrientation |
--            Qt::InvertedLandscapeOrientation)
--    , m_rotatesWindowContents(false)
--    , m_requestedState(RequestedRunning)
--    , m_isTouchApp(true)
--    , m_exemptFromLifecycle(false)
--    , m_manualSurfaceCreation(false)
--    , m_shellChrome(Mir::NormalChrome)
+ {
++    connect(&m_surfaceList, &MirSurfaceListModel::countChanged,
++        this, &ApplicationInfo::onSurfaceCountChanged, Qt::QueuedConnection);
++
++    m_surfaceCreationTimer.setSingleShot(true);
++    m_surfaceCreationTimer.setInterval(500);
++    connect(&m_surfaceCreationTimer, &QTimer::timeout, this, &ApplicationInfo::createSurface);
+ }
  ApplicationInfo::ApplicationInfo(QObject *parent)
--    : ApplicationInfoInterface(QString(), parent)
--    , m_stage(MainStage)
--    , m_state(Stopped)
--    , m_focused(false)
--    , m_fullscreen(false)
--    , m_session(0)
--    , m_supportedOrientations(Qt::PortraitOrientation |
--            Qt::LandscapeOrientation |
--            Qt::InvertedPortraitOrientation |
--            Qt::InvertedLandscapeOrientation)
--    , m_rotatesWindowContents(false)
--    , m_requestedState(RequestedRunning)
--    , m_isTouchApp(true)
--    , m_exemptFromLifecycle(false)
--    , m_manualSurfaceCreation(false)
--    , m_shellChrome(Mir::NormalChrome)
++    : ApplicationInfo(QString(), parent)
+ {
+ }
  ApplicationInfo::~ApplicationInfo()
+ {
--    delete m_session;
--}
--
--void ApplicationInfo::createSession()
--{
--    if (m_session || state() == ApplicationInfo::Stopped) { return; }
--
--    setSession(SessionManager::singleton()->createSession(appId(), m_screenshotFileName));
--}
--
--void ApplicationInfo::destroySession()
--{
--    Session *session = this->session();
--    setSession(nullptr);
--    delete session;
--}
--
--void ApplicationInfo::setSession(Session* session)
--{
--    if (m_session == session)
++}
++
++void ApplicationInfo::createSurface()
++{
++    if (state() == ApplicationInfo::Stopped) { return; }
++
++    QString surfaceName = name();
++    if (m_surfaceList.count() > 0) {
++        surfaceName.append(QString(" %1").arg(m_surfaceList.count()+1));
++    }
++
++    auto surfaceManager = SurfaceManager::instance();
++    if (!surfaceManager) {
++        WARNING_MSG("No SurfaceManager");
          return;
--
--    if (m_session) {
--        disconnect(this, 0, m_session, 0);
--        m_session->setApplication(nullptr);
--        m_session->setParent(nullptr);
--        Q_EMIT m_session->deregister();
--    }
--
--    m_session = session;
--
--    if (m_session) {
--        m_session->setApplication(this);
--        m_session->setParent(this);
--        m_session->setFullscreen(m_fullscreen);
--        SessionManager::singleton()->registerSession(m_session);
--        connect(m_session, &Session::surfaceAdded,
--                this, &ApplicationInfo::onSessionSurfaceAdded);
--        connect(m_session, &Session::fullscreenChanged, this, &ApplicationInfo::fullscreenChanged);
--
--        if (!m_manualSurfaceCreation) {
--            QTimer::singleShot(500, m_session, &Session::createSurface);
--        }
--    }
--
--    Q_EMIT sessionChanged(m_session);
++    }
++
++    auto surface = surfaceManager->createSurface(surfaceName,
++           Mir::NormalType,
++           fullscreen() ? Mir::FullscreenState : Mir::MaximizedState,
++           m_screenshotFileName);
++
++    surface->setShellChrome(m_shellChrome);
++
++    m_surfaceList.appendSurface(surface);
++
++    ++m_liveSurfaceCount;
++    connect(surface, &MirSurface::liveChanged, this, [this, surface](){
++        if (!surface->live()) {
++            --m_liveSurfaceCount;
++            if (m_liveSurfaceCount == 0) {
++                if (m_closingSurfaces.contains(surface)
++                        || (m_state == Running && m_requestedState == RequestedRunning)) {
++                    Q_EMIT closed();
++                }
++                setState(Stopped);
++            } else {
++                if (m_closingSurfaces.contains(surface) && m_requestedState == RequestedSuspended
++                        && m_closingSurfaces.count() == 1) {
++                    setState(Suspended);
++                }
++            }
++            m_closingSurfaces.removeAll(surface);
++        }
++    });
++    connect(surface, &MirSurface::closeRequested, this, [this, surface](){
++        m_closingSurfaces.append(surface);
++        if (m_state == Suspended) {
++            // resume to allow application to close its surface
++            setState(Running);
++        }
++    });
++    connect(surface, &MirSurface::focusRequested, this, &ApplicationInfo::focusRequested);
++
++    if (m_state == Starting) {
++        if (m_requestedState == RequestedRunning) {
++            setState(Running);
++        } else {
++            setState(Suspended);
++        }
++    }
+ }
  void ApplicationInfo::setIconId(const QString &iconId)
@@ -138,10 +154,6 @@
      if (screenshotFileName != m_screenshotFileName) {
          m_screenshotFileName = screenshotFileName;
--
--        if (m_session) {
--            m_session->setScreenshot(screenshotFileName);
--        }
+     }
+ }
@@ -172,38 +184,53 @@
  void ApplicationInfo::setState(State value)
+ {
      if (value != m_state) {
++        DEBUG_MSG(qPrintable(stateToStr(value)));
++        if (!m_manualSurfaceCreation && value == ApplicationInfo::Starting) {
++            Q_ASSERT(m_surfaceList.count() == 0);
++            m_surfaceCreationTimer.start();
++        } else if (value == ApplicationInfo::Stopped) {
++            m_surfaceCreationTimer.stop();
++            for (int i = 0; i < m_surfaceList.count(); ++i) {
++                MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));
++                surface->setLive(false);
++            }
++        }
++
          m_state = value;
          Q_EMIT stateChanged(value);
--
--        if (!m_manualSurfaceCreation && !m_session && m_state == ApplicationInfo::Starting) {
--            QTimer::singleShot(500, this, &ApplicationInfo::createSession);
--        } else if (m_state == ApplicationInfo::Stopped) {
--            Session *session = m_session;
--            setSession(nullptr);
--            delete session;
++    }
++}
++
++void ApplicationInfo::close()
++{
++    DEBUG_MSG("");
++
++    if (m_surfaceList.count() > 0) {
++        for (int i = 0; i < m_surfaceList.count(); ++i) {
++            MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));
++            surface->close();
+         }
--    }
--}
--
--void ApplicationInfo::setFocused(bool value)
--{
--    if (value != m_focused) {
--        m_focused = value;
--        Q_EMIT focusedChanged(value);
++    } else {
++        setState(Stopped);
++        Q_EMIT closed();
+     }
+ }
  void ApplicationInfo::setFullscreen(bool value)
+ {
      m_fullscreen = value;
--    if (m_session) {
--        m_session->setFullscreen(value);
++    if (m_surfaceList.rowCount() > 0) {
++        m_surfaceList.get(0)->setState(Mir::FullscreenState);
+     }
+ }
  bool ApplicationInfo::fullscreen() const
+ {
--    return m_session ? m_session->fullscreen() : m_fullscreen;
++    if (m_surfaceList.rowCount() > 0) {
++        return m_surfaceList.get(0)->state() == Mir::FullscreenState;
++    } else {
++        return m_fullscreen;
++    }
+ }
  void ApplicationInfo::setManualSurfaceCreation(bool value)
@@ -241,15 +268,28 @@
  void ApplicationInfo::setRequestedState(RequestedState value)
+ {
--    if (m_requestedState != value) {
--        m_requestedState = value;
--        Q_EMIT requestedStateChanged(m_requestedState);
--
--        if (m_requestedState == RequestedRunning && m_state == Suspended) {
++    if (m_requestedState == value) {
++        return;
++    }
++    DEBUG_MSG((value == RequestedRunning ? "RequestedRunning" : "RequestedSuspended") );
++
++    m_requestedState = value;
++    Q_EMIT requestedStateChanged(m_requestedState);
++
++    if (m_requestedState == RequestedRunning) {
++
++        if (m_state == Suspended) {
++            Q_ASSERT(m_liveSurfaceCount > 0);
              setState(Running);
--        } else if (m_requestedState == RequestedSuspended && m_state == Running) {
--            setState(Suspended);
++        } else if (m_state == Stopped) {
++            Q_ASSERT(m_liveSurfaceCount == 0);
++            // it's restarting
++            setState(Starting);
+         }
++
++    } else if (m_requestedState == RequestedSuspended && m_state == Running
++            && m_closingSurfaces.isEmpty()) {
++        setState(Suspended);
+     }
+ }
@@ -263,18 +303,6 @@
      m_isTouchApp = isTouchApp;
+ }
--void ApplicationInfo::onSessionSurfaceAdded(MirSurface* surface)
--{
--    if (surface != nullptr && m_state == Starting) {
--        if (m_requestedState == RequestedRunning) {
--            setState(Running);
--        } else {
--            setState(Suspended);
--        }
--        surface->setShellChrome(m_shellChrome);
--    }
--}
--
  bool ApplicationInfo::exemptFromLifecycle() const
+ {
      return m_exemptFromLifecycle;
@@ -305,7 +333,52 @@
  void ApplicationInfo::setShellChrome(Mir::ShellChrome shellChrome)
+ {
      m_shellChrome = shellChrome;
--    if (m_session && m_session->lastSurface()) {
--        m_session->lastSurface()->setShellChrome(shellChrome);
++    if (m_surfaceList.rowCount() > 0) {
++        static_cast<MirSurface*>(m_surfaceList.get(0))->setShellChrome(shellChrome);
++    }
++}
++
++bool ApplicationInfo::focused() const
++{
++    bool someSurfaceHasFocus = false; // to be proven wrong
++    for (int i = 0; i < m_surfaceList.count() && !someSurfaceHasFocus; ++i) {
++        someSurfaceHasFocus = m_surfaceList.get(i)->focused();
++    }
++    return someSurfaceHasFocus;
++}
++
++void ApplicationInfo::setFocused(bool value)
++{
++    if (focused() == value) {
++        return;
++    }
++
++    if (value) {
++        if (m_surfaceList.count() > 0) {
++            m_surfaceList.get(0)->requestFocus();
++        }
++    } else {
++        for (int i = 0; i < m_surfaceList.count(); ++i) {
++            MirSurface *surface = static_cast<MirSurface*>(m_surfaceList.get(i));
++            if (surface->focused()) {
++                surface->setFocused(false);
++            }
++        }
++    }
++}
++
++void ApplicationInfo::onSurfaceCountChanged()
++{
++    if (m_surfaceList.count() == 0 && m_state == Running) {
++        setState(Stopped);
++    }
++}
++
++void ApplicationInfo::requestFocus()
++{
++    if (m_surfaceList.count() == 0) {
++        Q_EMIT focusRequested();
++    } else {
++        m_surfaceList.get(0)->requestFocus();
+     }
+ }
 === modified file 'tests/mocks/Unity/Application/ApplicationInfo.h'
 --- tests/mocks/Unity/Application/ApplicationInfo.h	2016-03-15 20:59:07 +0000
 +++ tests/mocks/Unity/Application/ApplicationInfo.h	2016-04-20 17:09:16 +0000
@@ -20,25 +20,32 @@
  #include <QObject>
  class MirSurface;
--class Session;
  // unity-api
  #include <unity/shell/application/ApplicationInfoInterface.h>
  #include <unity/shell/application/Mir.h>
++#include "MirSurfaceListModel.h"
++
++#include <QList>
++#include <QTimer>
++
  using namespace unity::shell::application;
  class ApplicationInfo : public ApplicationInfoInterface {
      Q_OBJECT
++    ////
++    // FIXME: Remove those
      Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged)
--    Q_PROPERTY(Session* session READ session NOTIFY sessionChanged)
      // Only exists in this fake implementation
      // whether the test code will explicitly control the creation of the application surface
      Q_PROPERTY(bool manualSurfaceCreation READ manualSurfaceCreation WRITE setManualSurfaceCreation NOTIFY manualSurfaceCreationChanged)
++    Q_PROPERTY(QString screenshot READ screenshot CONSTANT)
++
  public:
      ApplicationInfo(QObject *parent = nullptr);
      ApplicationInfo(const QString &appId, QObject *parent = nullptr);
@@ -66,8 +73,7 @@
      Q_INVOKABLE void setState(State value);
      State state() const override { return m_state; }
--    void setFocused(bool value);
--    bool focused() const override { return m_focused; }
++    bool focused() const override;
      QString splashTitle() const override { return QString(); }
      QUrl splashImage() const override { return QUrl(); }
@@ -100,21 +106,26 @@
      void setInitialSurfaceSize(const QSize &size) override;
      Q_INVOKABLE void setShellChrome(Mir::ShellChrome shellChrome);
--public:
--    void setSession(Session* session);
--    Session* session() const { return m_session; }
++
++    MirSurfaceListInterface* surfaceList() override { return &m_surfaceList; }
++
++    void setFocused(bool value);
++
++    //////
++    // internal mock stuff
++    void close();