Unity 8

Merge lp:~unity-team/unity8/mirCompositor into lp:unity8

mirCompositor
Merge into trunk

Proposed by kevin gunn on 2014-07-02

Status:

Merged

Approved by:

Gerry Boland on 2014-07-29

Approved revision:

1104

Merged at revision:

1088

Proposed branch:

lp:~unity-team/unity8/mirCompositor

Merge into:

lp:unity8

Diff against target:

6483 lines (+3413/-1522)

52 files modified

debian/changelog (+14/-0)
debian/control (+1/-2)
plugins/Utils/CMakeLists.txt (+1/-0)
plugins/Utils/easingcurve.cpp (+5/-1)
plugins/Utils/plugin.cpp (+2/-0)
plugins/Utils/windowkeysfilter.cpp (+57/-0)
plugins/Utils/windowkeysfilter.h (+51/-0)
qml/Components/Dialogs.qml (+217/-0)
qml/Components/DraggingArea.qml (+4/-0)
qml/Components/InputMethod.qml (+79/-0)
qml/Components/PageHeader.qml (+3/-1)
qml/Dash/Apps/RunningApplicationTile.qml (+45/-37)
qml/Dash/DashContent.qml (+4/-0)
qml/Launcher/Launcher.qml (+1/-1)
qml/Panel/Indicators.qml (+3/-0)
qml/Shell.qml (+171/-393)
qml/Stages/Animations/BaseSurfaceAnimation.qml (+93/-0)
qml/Stages/Animations/DarkenAndFadeInAnimation.qml (+48/-0)
qml/Stages/Animations/SwipeFromBottomAnimation.qml (+48/-0)
qml/Stages/Animations/SwipeUpAnimation.qml (+49/-0)
qml/Stages/PhoneStage.qml (+173/-265)
qml/Stages/SidestageHandle.qml (+0/-22)
qml/Stages/Splash.qml (+68/-0)
qml/Stages/SpreadDelegate.qml (+193/-29)
qml/Stages/StageWithSideStage.qml (+0/-413)
qml/Stages/SurfaceContainer.qml (+123/-0)
qml/Stages/SwitchingApplicationImage.qml (+0/-81)
qml/Stages/TabletStage.qml (+568/-0)
qml/Stages/TransformedSpreadDelegate.qml (+36/-30)
qml/Stages/TransformedTabletSpreadDelegate.qml (+369/-0)
src/CMakeLists.txt (+0/-3)
src/main.cpp (+14/-89)
tests/mocks/Unity/Application/Application.qmltypes (+0/-2)
tests/mocks/Unity/Application/ApplicationDBusAdaptor.cpp (+75/-0)
tests/mocks/Unity/Application/ApplicationDBusAdaptor.h (+43/-0)
tests/mocks/Unity/Application/ApplicationInfo.cpp (+71/-23)
tests/mocks/Unity/Application/ApplicationInfo.h (+22/-9)
tests/mocks/Unity/Application/ApplicationManager.cpp (+60/-31)
tests/mocks/Unity/Application/ApplicationManager.h (+15/-9)
tests/mocks/Unity/Application/CMakeLists.txt (+6/-2)
tests/mocks/Unity/Application/MirSurfaceItem.cpp (+172/-0)
tests/mocks/Unity/Application/MirSurfaceItem.h (+121/-0)
tests/mocks/Unity/Application/SurfaceManager.cpp (+73/-0)
tests/mocks/Unity/Application/SurfaceManager.h (+54/-0)
tests/mocks/Unity/Application/VirtualKeyboard.cpp (+55/-0)
tests/mocks/Unity/Application/VirtualKeyboard.h (+35/-0)
tests/mocks/Unity/Application/plugin.cpp (+16/-9)
tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml (+23/-2)
tests/qmltests/Launcher/tst_Launcher.qml (+11/-2)
tests/qmltests/Panel/tst_ActiveCallHint.qml (+1/-0)
tests/qmltests/Stages/tst_PhoneStage.qml (+9/-56)
tests/qmltests/tst_Shell.qml (+111/-10)

To merge this branch:

bzr merge lp:~unity-team/unity8/mirCompositor

Related bugs:

Bug #1090358: launcher should appear above OSK	Undecided	Fix Released
Bug #1181332: Sidestage brought in when focusing mainstage app (even when there's no sidestage apps)	Medium	Fix Released
Bug #1212637: App refocuses after it's swiped away during startup	Undecided	Fix Released
Bug #1232684: [switcher] Closing apps is too complicated	Undecided	Fix Released
Bug #1275808: [sidestage] Window animations not smooth, some flickering	High	Fix Released
Bug #1313842: Background app screenshot appears when launching a video in mediaplayer-app	Undecided	Fix Released
Bug #1323850: osk displayed on top of shell components	High	Fix Released
Bug #1324081: The 'Recent' Apps category in the Apps scope is a distraction	High	Fix Released
Bug #1337908: [QtComp] cannot reply from the 'Incoming' menu as OSK does not appear	Undecided	Fix Released
Bug #1337930: [QtComp] Launching apps from lockscreen does not auto-hide greeter	Undecided	Fix Released
Bug #1340189: [QtComp] Application spread freezes when used with multiple fingers	Undecided	Fix Released
Bug #1342705: [QtComp] Top bar covers part of OSK when device is rotated	Undecided	Fix Released
Bug #1342768: [QtComp] Apps can't bring up keyboard after screen is turned off and on again	High	Fix Released
Bug #1344082: [QtComp] launcher and indicators panel can be accessed while shutdown dialog is shown	Undecided	Fix Released
Bug #1346330: [QtComp] Vkb stays above indicators panel	Undecided	Fix Released
Bug #1347919: App launch animation not shown when an app is in foreground	Undecided	Fix Released
Bug #1348686: [QtComp] Indicator does not close on invoking external application	High	Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Gerry Boland (community)		2014-07-18	Approve on 2014-07-29
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2014-07-25
Michael Zanetti (community)	c++ code review		Approve on 2014-07-18
Michael Terry	debian-packaging	2014-07-02	Approve on 2014-07-15
Vesa Rautiainen (community)	design	2014-07-08	Approve on 2014-07-08
Review via email: mp+225378@code.launchpad.net

Commit message

changes for Qtcompositor as a plugin to mir

Description of the change

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

https://code.launchpad.net/~unity-team/platform-api/devel-for-qtmircompositor/+merge/225320
https://code.launchpad.net/~mir-team/qtubuntu/ubuntumirclient-only/+merge/224978
https://code.launchpad.net/~unity-team/ubuntu-system-settings/use-qtComp/+merge/225540
https://code.launchpad.net/~gerboland/unity8-desktop-session/qtcomp/+merge/225884

Also requires lp:qtmir and lp:~gerboland/+junk/ubuntu-touch-meta_qtcomp

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

tons

* 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?

yep

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

requested here

Revision history for this message

Vesa Rautiainen (vesar) wrote on 2014-07-08:

Design-approved

review: Approve (design)

Revision history for this message

Michael Terry (mterry) wrote on 2014-07-15:

I only looked at the debian/* changes, but they look fine provided:
- debian/changelog conflict is fixed
- qtmir actually lands in utopic

Revision history for this message

Michael Terry (mterry) on 2014-07-15:

review: Approve (debian-packaging)

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-16:

Ok, I opened this up for review. The process is as follows:
- Gerry reviews the Tablet/Phone stages and anything else Michael Zanetti played with
- Michael Zanetti reviews the remainder (perf tweaks Gerry applied + src/main.cpp)
- we have packaging +1, which is great

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-17:

Changes in main.cpp look good to me!

review: Approve (c++ code review)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

FAILED: Continuous integration, rev:1052
http://jenkins.qa.ubuntu.com/job/unity8-ci/3473/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2148/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/474/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/567/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/567/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/567/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3307/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

FAILED: Continuous integration, rev:1053
http://jenkins.qa.ubuntu.com/job/unity8-ci/3475/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2155/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/476/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/569/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/569/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/569/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3315/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-17:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-18:

Revoking my approval until I've reviewed that whole lot of C++ code that appeared over night.

review: Abstain

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-18:

Reviewed new KeyHandler code. Looks good.

review: Approve (c++ code review)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-18:

> Reviewed new KeyHandler code. Looks good.

To be clear, I don't think this is the final thing we need in the end (once we need Keyboard navigation through the shell etc). I'm afraid we have to go back to the "focus mayhem" at that point. However, we also lack policy stuff for handling system keys (like Volume Up/Down) which prevents us to put in place the proper solution just yet, so I think this is a fine solution for now.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Components/Lockscreen.qml'
- property url background: ""
+ property url background: shell.background
Breaks encapsulation

=== modified file 'qml/Shell.qml'
- background: shell.background
+ //background: shell.background // FIXME: Commenting out as Qt was complaining about this line
I'm not sure breaking encapsulation is better than fixing a warning.

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Dash/Apps/RunningApplicationTile.qml'
+ x: 0
+ y: 0
that's the default anyway.

+ property bool isLandscape: sourceSize.width > sourceSize.height
+ property real maxDimension: units.gu(17)
Both could be readonly.

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Shell.qml'
-FocusScope {
+Item {
I'd rather we didn't do this. We're not really doing focus management properly, but IMO there's no reason to remove this focusscope.

+ WindowKeysFilter {
Do we have a policy for placing non-UI chunks of QML under the visual ones? Just curious

+ return stagesDragArea.progress
semicolon (just because I see the previous lines in the diff add one)

+ // It might technically not be fullyShown but visually it just looks so.
+ property bool roughlyFullyShown: x >= 0 && x <= units.gu(1)
The purpose if this is a mystery to me. Why is fullyShown not the correct thing to use to decide that the spread is interactive? Can we not do something more obvious?

+ property bool topmostApplicationIsFullscreen:
readonly?

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Stages/PhoneStage.qml'
+ property bool locked: spreadView.phase == 2
readonly?

+ spreadView.contentX = -spreadView.shift
+ priv.switchToApp(appId)
nit-pick - semicolons?

+ if (behavioredIndex == 1 ....
are these floating point comparisons safe?

+ // Limiting progress to ~0 and 1.7
1.7 a bit magic, is that roughly 1 + 0.7 = width of the transformed tile on the left?

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Stages/SpreadDelegate.qml'
+ // FIXME: I would rather not need to do this, but currently it doesn't get
+ // active focus without it and I don't know why.
+ onFocusChanged: forceSurfaceActiveFocusIfReady();
+ onParentChanged: forceSurfaceActiveFocusIfReady();
+ onEnabledChanged: forceSurfaceActiveFocusIfReady();
+ function forceSurfaceActiveFocusIfReady() {
+ if (surface.focus && surface.parent === surfaceContainer && surface.enabled) {
+ surface.forceActiveFocus();
+ }
+ }
I'm *really* not a fan of this, but as it is a FIXME, and as long as it behaves correctly we'll live with it for now.

+ border { left: 50; right: 50; top: 50; bottom: 50 }
No GU?

+ if ((dragVelocity < -600 && distance < -units.gu(8))
more magic numbers? Are they phone shell specific? Since we use GU for distances, doesn't that mean we need to scale velocities against GU too?
Probably a personal thing, but I do flick apps closed by accident. Can be a later bugfix though.

+ animation.from = dragArea.distance
+ animation.to = 0
+ root.closed()
semicolons or no?

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-07-18:

> === modified file 'qml/Shell.qml'
> -FocusScope {
> +Item {
> I'd rather we didn't do this. We're not really doing focus management
> properly, but IMO there's no reason to remove this focusscope.

The reason is that there's absolutely no use for this FocusScope there. Getting rid of unused stuff is always a good thing.

> + // It might technically not be fullyShown but visually it just looks so.
> + property bool roughlyFullyShown: x >= 0 && x <= units.gu(1)
> The purpose if this is a mystery to me. Why is fullyShown not the correct
> thing to use to decide that the spread is interactive? Can we not do something
> more obvious?

To avoid fidgety behavior when the stage moves only a pixel or so: imperceptible to the human eye so from the user's POV it's still fully shown be we would be already unfocusing the app etc.

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== added file 'qml/Stages/TabletStage.qml'
+ objectName: "stages"
that a good name? Also PhoneStage has no objectName set at all, should we add one?

"overlay" = sidestage effectively, right? Just the term threw me for a bit. Rename isn't needed, but perhaps a comment saying so would be nice.

"invalid" state is when no app is open, so spread should not be shown? That really an "invalid" state, or just empty?

+ property int phase
You were kind enough to add a nice comment in PhoneStage explaining the different stages, could you do the same here please?

+ property bool locked: spreadView.phase == 2
+ property string focusedAppId: ApplicationManager.focusedApplicationId
readonly? there's a bunch of properties in the Flickable that could also be readonly.

+ // Add 1 pixel to make sure we definitely hit positionMarker4 even with rounding errors of the animation.
+ snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4 + 1;
Math.ceil?

"ApplicationInfoInterface.MainStage" <- bit of a mouthful, let's try to shorten that in future :)

+ function indexToZIndex(index) {
a few more comments in here would help, I'm struggling to figure it out.

+ anchors.leftMargin: spreadView.width - spreadView.sideStageWidth + spreadView.sideStageWidth * sideStageDragHandle.progress
can compact the maths a tiny bit

+ } else if (progress < spreadView.positionMarker1 + snappingCurve.period){
nitpick: space before opening brace

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== modified file 'qml/Stages/TransformedSpreadDelegate.qml'
+ visible: progress >= 0 && progress < 1.7
that magic 1.7 again. Quick comment would be enough probably.

+ var animatedEndDistance = linearAnimation(0, 2, root.endDistance, 0, root.progress)
semicolon

=== added file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
some more readonly properties...

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-18:

> === modified file 'qml/Stages/PhoneStage.qml'
> + property bool locked: spreadView.phase == 2
> readonly?

fixed.

> + spreadView.contentX = -spreadView.shift
> + priv.switchToApp(appId)
> nit-pick - semicolons?

fixed

> + if (behavioredIndex == 1 ....
> are these floating point comparisons safe?

Haven't seen any troubles, also this is straight bound to an integer property, just added a Behavior. No floating point calculations involved. I don't think its worth adding some additional fuzziness checks but if you want me to, I can do.

>
> + // Limiting progress to ~0 and 1.7
> 1.7 a bit magic, is that roughly 1 + 0.7 = width of the transformed tile on
> the left?

I tried to improve the comment a bit. Hope its more clear now.

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-18:

> === modified file 'qml/Stages/SpreadDelegate.qml'
> + border { left: 50; right: 50; top: 50; bottom: 50 }
> No GU?

in this case its pixels in the source image, so no.

>
> + if ((dragVelocity < -600 && distance < -units.gu(8))
> more magic numbers? Are they phone shell specific? Since we use GU for
> distances, doesn't that mean we need to scale velocities against GU too?
> Probably a personal thing, but I do flick apps closed by accident. Can be a
> later bugfix though.

Magic numbers dictated by the design prototype :) Comment added. But you're right, velocity should be given in gu indeed. I've fixed that.

>
> + animation.from = dragArea.distance
> + animation.to = 0
> + root.closed()
> semicolons or no?

yep, added

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-18:

=== added file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
+ property bool otherSelected: false
something selected on the other stage, is it? So both need to animate forward? Quick comment would help.

+ // Required to be an item because we're using states on it.
I think you can use a StateGroup inside a QtObject.

nextInStack, movedActive and animatedEndDistance could be readonly. XTranslate, scale, angle, opacityTransform and topMarginProgress too

+ var shouldMoveAway = spreadView.nextInStack >= 0 && movedActive && (ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage || model.stage == ApplicationInfoInterface.SideStage);
line too long

Rest of the file looks ok, the math is quite nontrivial but it looks sane. So mainly small issues!

review: Needs Fixing

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-07-18:

> === modified file 'qml/Components/Lockscreen.qml'
> - property url background: ""
> + property url background: shell.background
> Breaks encapsulation
>
> === modified file 'qml/Shell.qml'
> - background: shell.background
> + //background: shell.background // FIXME: Commenting out as Qt was
> complaining about this line
> I'm not sure breaking encapsulation is better than fixing a warning.

I wasn't just a warning. Shell.qml was failing to load because of it. Thankfully the QML engine bug that caused it must have been fixed in the meantime (likely the one that Albert Alstals fixed) and restoring that line no longer causes any problem.

Fixed.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2014-07-18:

> > === modified file 'qml/Shell.qml'
> > -FocusScope {
> > +Item {
> > I'd rather we didn't do this. We're not really doing focus management
> > properly, but IMO there's no reason to remove this focusscope.
>
> The reason is that there's absolutely no use for this FocusScope there.
> Getting rid of unused stuff is always a good thing.
>
>
> > + // It might technically not be fullyShown but visually it just looks so.
> > + property bool roughlyFullyShown: x >= 0 && x <= units.gu(1)
> > The purpose if this is a mystery to me. Why is fullyShown not the correct
> > thing to use to decide that the spread is interactive? Can we not do
> something
> > more obvious?
>
> To avoid fidgety behavior when the stage moves only a pixel or so:
> imperceptible to the human eye so from the user's POV it's still fully shown
> be we would be already unfocusing the app etc.

Actual example:
1- launch Gallery
2- lay finger on the left edge of the screen

Without roughlyFullyShown:
Indicators bar comes in immediately. Might even jump back and forth.

With roughlyFullyShown:
Nothing happens

The cause of it is that when you lay your finger there it causes stage to move a pixel or so (or maybe even less then a pixel), which makes fullyShown=false, and that's obviously not the actual situation.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

FAILED: Continuous integration, rev:1068
http://jenkins.qa.ubuntu.com/job/unity8-ci/3489/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2203/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/491/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/583/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/583/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/583/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3376/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-18:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-21:

> === added file 'qml/Stages/TabletStage.qml'
> + objectName: "stages"
> that a good name? Also PhoneStage has no objectName set at all, should we add
> one?

Well, there's tests for PhoneStage but not TabletStage yet. I'll add them when the split mode will be implemented.

>
> "overlay" = sidestage effectively, right? Just the term threw me for a bit.
> Rename isn't needed, but perhaps a comment saying so would be nice.

It is sidestage in overlay mode. Parts of the code are prepared for split mode already. I've added some more comments.

>
> "invalid" state is when no app is open, so spread should not be shown? That
> really an "invalid" state, or just empty?

fair enough. renamed.

>
>
> + property int phase
> You were kind enough to add a nice comment in PhoneStage explaining the
> different stages, could you do the same here please?

done

>
> + property bool locked: spreadView.phase == 2
> + property string focusedAppId: ApplicationManager.focusedApplicationId
> readonly? there's a bunch of properties in the Flickable that could also be
> readonly.

made some more readonly.

>
> + // Add 1 pixel to make sure we definitely hit positionMarker4 even with
> rounding errors of the animation.
> + snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4
> + 1;
> Math.ceil?

I really want it to step over the marker, not just reach it.

>
> "ApplicationInfoInterface.MainStage" <- bit of a mouthful, let's try to
> shorten that in future :)

Better than guessing what AII.MS might be, no? The "Interface" is a bit odd in deed" but well... That's how our architecture works.

>
> + function indexToZIndex(index) {
> a few more comments in here would help, I'm struggling to figure it out.

done

>
> + anchors.leftMargin: spreadView.width - spreadView.sideStageWidth +
> spreadView.sideStageWidth * sideStageDragHandle.progress
> can compact the maths a tiny bit

I tried for a bunch of hours to boot my N10. No chance, not even with the released images. Don't want to change that blindly without testing it... I'll try to do so when the N10 image comes back.

>
> + } else if (progress < spreadView.positionMarker1 + snappingCurve.period){
> nitpick: space before opening brace

done.

> === added file 'qml/Stages/TabletStage.qml'
> + objectName: "stages"
> that a good name? Also PhoneStage has no objectName set at all, should we add
> one?

Well, there's tests for PhoneStage but not TabletStage yet. I'll add them when the split mode will be implemented.

> 
> "overlay" = sidestage effectively, right? Just the term threw me for a bit.
> Rename isn't needed, but perhaps a comment saying so would be nice.

It is sidestage in overlay mode. Parts of the code are prepared for split mode already. I've added some more comments.

> 
> "invalid" state is when no app is open, so spread should not be shown? That
> really an "invalid" state, or just empty?

fair enough. renamed.

> 
> 
> + property int phase
> You were kind enough to add a nice comment in PhoneStage explaining the
> different stages, could you do the same here please?

done

> 
> + property bool locked: spreadView.phase == 2
> + property string focusedAppId: ApplicationManager.focusedApplicationId
> readonly? there's a bunch of properties in the Flickable that could also be
> readonly.

made some more readonly.

> 
> + // Add 1 pixel to make sure we definitely hit positionMarker4 even with
> rounding errors of the animation.
> + snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4
> + 1;
> Math.ceil?

I really want it to step over the marker, not just reach it.

> 
> "ApplicationInfoInterface.MainStage" <- bit of a mouthful, let's try to
> shorten that in future :)

Better than guessing what AII.MS might be, no? The "Interface" is a bit odd in deed" but well... That's how our architecture works.

> 
> + function indexToZIndex(index) {
> a few more comments in here would help, I'm struggling to figure it out.

done

> 
> + anchors.leftMargin: spreadView.width - spreadView.sideStageWidth +
> spreadView.sideStageWidth * sideStageDragHandle.progress
> can compact the maths a tiny bit

I tried for a bunch of hours to boot my N10. No chance, not even with the released images. Don't want to change that blindly without testing it... I'll try to do so when the N10 image comes back.

> 
> + } else if (progress < spreadView.positionMarker1 + snappingCurve.period){
> nitpick: space before opening brace

done.

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-21:

> === modified file 'qml/Stages/TransformedSpreadDelegate.qml'
> + visible: progress >= 0 && progress < 1.7
> that magic 1.7 again. Quick comment would be enough probably.

Well there is a comment saying that this the min/max values of progress... Should I duplicate the entire "how I got to those numbers" text?

>
> + var animatedEndDistance = linearAnimation(0, 2, root.endDistance, 0,
> root.progress)
> semicolon

added

>
> === added file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
> some more readonly properties...

I don't really agree with this. There could be some of those made readonly, not all. But tbh seems to cause more mess than anything else. Again this is not public API...

The thing with readonly is that you also can't apply any Behavior or state changes on that property any more... Having "angle" readonly, while keeping xTranslate read-write etc doesn't seem like doing any good to me.

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-21:

> + anchors.leftMargin: spreadView.width - spreadView.sideStageWidth +
> spreadView.sideStageWidth * sideStageDragHandle.progress
> can compact the maths a tiny bit

Thanks to dednick's work on the FakeAppManager I could test this on the Desktop again. I compressed the math a bit, although I'm not sure if it makes it more clear what its doing... Sometimes I intentionally "uncompress" some maths in order to make it more readable....

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2014-07-21:

> === added file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
> + property bool otherSelected: false
> something selected on the other stage, is it? So both need to animate forward?
> Quick comment would help.

done.

> + // Required to be an item because we're using states on it.
> I think you can use a StateGroup inside a QtObject.

Tried it, doesn't seem to work...

> nextInStack, movedActive and animatedEndDistance could be readonly.
> XTranslate, scale, angle, opacityTransform and topMarginProgress too

nope. The state wants write access to it. See previous comment on readonly props.

>
> + var shouldMoveAway = spreadView.nextInStack >= 0 && movedActive &&
> (ApplicationManager.get(spreadView.nextInStack).stage ===
> ApplicationInfoInterface.MainStage || model.stage ==
> ApplicationInfoInterface.SideStage);
> line too long

done

> Rest of the file looks ok, the math is quite nontrivial but it looks sane. So
> mainly small issues!

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-21:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-21:

Thanks for those changes. I've nothing more to add. It works beautifully, thank you!

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-21:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-21:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-22:

FAILED: Continuous integration, rev:1077
http://jenkins.qa.ubuntu.com/job/unity8-ci/3525/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2305/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/527/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/619/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/619/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/619/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3512/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-22:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-23:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-23:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-23:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-23:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

FAILED: Continuous integration, rev:1093
http://jenkins.qa.ubuntu.com/job/unity8-ci/3586/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2461/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/588/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/680/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/680/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/680/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3704/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

FAILED: Continuous integration, rev:1094
http://jenkins.qa.ubuntu.com/job/unity8-ci/3587/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2466/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/589/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/681/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/681/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/681/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3709/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

FAILED: Continuous integration, rev:1095
http://jenkins.qa.ubuntu.com/job/unity8-ci/3588/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2467/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/590/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/682/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/682/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/682/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3710/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-24:

FAILED: Continuous integration, rev:1097
http://jenkins.qa.ubuntu.com/job/unity8-ci/3589/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2470/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/591/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/683/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/683/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/683/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3713/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-25:

FAILED: Continuous integration, rev:1098
http://jenkins.qa.ubuntu.com/job/unity8-ci/3590/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-deb-autopilot-utopic-touch/2481/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-phablet-qmluitests-utopic/592/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-amd64-ci/684/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-armhf-ci/684/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity8-utopic-i386-ci/684/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3724/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-25:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-07-25:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-28:

One final fix, approved

review: Approve

Revision history for this message

Gerry Boland (gerboland) wrote on 2014-07-29:

Yet another final fix

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:

Mohammad Rakibul Hasan

Unity Team

 === modified file 'debian/changelog'
 --- debian/changelog	2014-07-25 10:47:35 +0000
 +++ debian/changelog	2014-07-29 14:07:22 +0000
@@ -1,3 +1,17 @@
++unity8 (8.00) UNRELEASED; urgency=medium
++
++  [ Gerry Boland ]
++  [ Daniel d'Andrada ]
++  * Re-architecture unity8 to use the QtMirCompositor library so that
++    the Qt scenegraph renderer is used as the Mir compositor, and
++    application surfaces are added to the QML scene as items.
++
++  [ Michael Zanetti ]
++  * Port phone right-edge spread code to use QtCompositor
++  * Add right-edge spread animation for tablet
++
++ -- Gerry Boland <gerry.boland@canonical.com>  Thu, 10 Jul 2014 10:34:18 +0100
++
  unity8 (7.90+14.10.20140725-0ubuntu1) utopic; urgency=low
    [ CI bot ]
 === modified file 'debian/control'
 --- debian/control	2014-07-24 20:40:44 +0000
 +++ debian/control	2014-07-29 14:07:22 +0000
@@ -24,7 +24,6 @@
                 libqmenumodel-dev (>= 0.2.8),
                 libqt5xmlpatterns5-dev,
                 libunity-api-dev (>= 7.85),
--               libunity-mir-dev,
                 libusermetricsoutput1-dev,
                 libxcb1-dev,
                 pkg-config,
@@ -80,10 +79,10 @@
  Depends: gsettings-desktop-schemas,
           libcap2-bin,
           libglib2.0-bin,
--         libunity-mir1 (>= 0.4),
           qmenumodel-qml (>= 0.2.8),
           qml-module-qtquick-xmllistmodel,
           qtdeclarative5-gsettings1.0,
++         qtdeclarative5-qtmir-plugin (>= 0.4),
           qtdeclarative5-ubuntu-settings-components (>= 0.3),
           qtdeclarative5-ubuntu-telephony0.1,
           unity-launcher-impl-3,
 === modified file 'plugins/Utils/CMakeLists.txt'
 --- plugins/Utils/CMakeLists.txt	2014-06-23 16:20:51 +0000
 +++ plugins/Utils/CMakeLists.txt	2014-07-29 14:07:22 +0000
@@ -15,6 +15,7 @@
      qsortfilterproxymodelqml.cpp
      timeformatter.cpp
      unitymenumodelpaths.cpp
++    windowkeysfilter.cpp
      easingcurve.cpp
      plugin.cpp
+     )
 === modified file 'plugins/Utils/easingcurve.cpp'
 --- plugins/Utils/easingcurve.cpp	2014-06-30 16:02:05 +0000
 +++ plugins/Utils/easingcurve.cpp	2014-07-29 14:07:22 +0000
@@ -34,7 +34,11 @@
  void EasingCurve::setType(const QEasingCurve::Type &type)
+ {
--    m_easingCurve.setType(type);
++    // FIXME: Working around bug https://bugreports.qt-project.org/browse/QTBUG-38686 here
++    QEasingCurve newCurve;
++    newCurve.setType(type);
++    newCurve.setPeriod(m_easingCurve.period());
++    m_easingCurve = newCurve;
      Q_EMIT typeChanged();
+ }
 === modified file 'plugins/Utils/plugin.cpp'
 --- plugins/Utils/plugin.cpp	2014-06-23 16:20:51 +0000
 +++ plugins/Utils/plugin.cpp	2014-07-29 14:07:22 +0000
@@ -30,6 +30,7 @@
  #include "qsortfilterproxymodelqml.h"
  #include "timeformatter.h"
  #include "unitymenumodelpaths.h"
++#include "windowkeysfilter.h"
  #include "easingcurve.h"
  void UtilsPlugin::registerTypes(const char *uri)
@@ -40,6 +41,7 @@
      qmlRegisterType<QSortFilterProxyModelQML>(uri, 0, 1, "SortFilterProxyModel");
      qmlRegisterType<UnityMenuModelPaths>(uri, 0, 1, "UnityMenuModelPaths");
      qmlRegisterType<TimeFormatter>(uri, 0, 1, "TimeFormatter");
++    qmlRegisterType<WindowKeysFilter>(uri, 0, 1, "WindowKeysFilter");
      qmlRegisterType<GDateTimeFormatter>(uri, 0, 1, "GDateTimeFormatter");
      qmlRegisterType<EasingCurve>(uri, 0, 1, "EasingCurve");
+ }
 === added file 'plugins/Utils/windowkeysfilter.cpp'
 --- plugins/Utils/windowkeysfilter.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/windowkeysfilter.cpp	2014-07-29 14:07:22 +0000
@@ -0,0 +1,57 @@
++/*
++ * 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/>.
++ *
++ * Author: Daniel d'Andrada <daniel.dandrada@canonical.com>
++ */
++
++#include "windowkeysfilter.h"
++
++#include <QQuickWindow>
++
++WindowKeysFilter::WindowKeysFilter(QQuickItem *parent)
++    : QQuickItem(parent)
++{
++    connect(this, &QQuickItem::windowChanged,
++            this, &WindowKeysFilter::setupFilterOnWindow);
++}
++
++bool WindowKeysFilter::eventFilter(QObject *watched, QEvent *event)
++{
++    Q_ASSERT(!m_filteredWindow.isNull());
++    Q_ASSERT(watched == static_cast<QObject*>(m_filteredWindow.data()));
++
++    if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
++        // Let QML see this event and decide if it does not want it
++        event->accept();
++        QCoreApplication::sendEvent(this, event);
++        return event->isAccepted();
++    } else {
++        // Not interested
++        return false;
++    }
++}
++
++void WindowKeysFilter::setupFilterOnWindow(QQuickWindow *window)
++{
++    if (!m_filteredWindow.isNull()) {
++        m_filteredWindow->removeEventFilter(this);
++        m_filteredWindow.clear();
++    }
++
++    if (window) {
++        window->installEventFilter(this);
++        m_filteredWindow = window;
++    }
++}
 === added file 'plugins/Utils/windowkeysfilter.h'
 --- plugins/Utils/windowkeysfilter.h	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/windowkeysfilter.h	2014-07-29 14:07:22 +0000
@@ -0,0 +1,51 @@
++/*
++ * 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/>.
++ *
++ * Author: Daniel d'Andrada <daniel.dandrada@canonical.com>
++ */
++
++#ifndef UNITY_WINDOWKEYSFILTER_H
++#define UNITY_WINDOWKEYSFILTER_H
++
++#include <QQuickItem>
++#include <QPointer>
++
++/*
++   Receives all key events that arrive in the QQuickWindow where this item is placed.
++
++   Rejected key events will be allowed to be processed normally by the QQuickWindow whereas
++   accepted ones will be filtered out. Events are accepted by default, so make sure you reject
++   the keys you're not interested in.
++
++   If more than one WindowKeysFilter exist in the same QML scene (and thus in the same QQuickWindow)
++   they will be called in the order of creation, which can be tricky to assess. So the best practice
++   is to have at most one WindowKeysFilter per QML scene.
++ */
++class WindowKeysFilter : public QQuickItem
++{
++    Q_OBJECT
++public:
++    WindowKeysFilter(QQuickItem *parent = 0);
++
++    bool eventFilter(QObject *watched, QEvent *event);
++
++private Q_SLOTS:
++    void setupFilterOnWindow(QQuickWindow *window);
++
++private:
++    QPointer<QQuickWindow> m_filteredWindow;
++};
++
++#endif // UNITY_WINDOWKEYSFILTER_H
 === added file 'qml/Components/Dialogs.qml'
 --- qml/Components/Dialogs.qml	1970-01-01 00:00:00 +0000
 +++ qml/Components/Dialogs.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,217 @@
++/*
++ * 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.0
++
++import Unity.Application 0.1
++import Unity.Session 0.1
++import Ubuntu.Components 0.1
++import Ubuntu.Components.Popups 0.1
++
++Item {
++    id: root
++
++    function onPowerKeyPressed() {
++        if (!powerKeyTimer.running) {
++            powerKeyTimer.start();
++        }
++    }
++
++    function onPowerKeyReleased() {
++        powerKeyTimer.stop();
++    }
++
++    signal powerOffClicked();
++
++    QtObject {
++        id: d // private stuff
++
++        property bool dialogShown: false
++
++        function showPowerDialog() {
++            if (!d.dialogShown) {
++                d.dialogShown = true;
++                PopupUtils.open(powerDialog, root, {"z": root.z});
++            }
++        }
++    }
++
++    Timer {
++        id: powerKeyTimer
++        interval: 2000
++        repeat: false
++        triggeredOnStart: false
++
++        onTriggered: {
++            d.showPowerDialog();
++        }
++    }
++
++    Component {
++        id: logoutDialog
++        Dialog {
++            id: dialogueLogout
++            title: "Logout"
++            text: "Are you sure that you want to logout?"
++            Button {
++                text: "Cancel"
++                onClicked: {
++                    PopupUtils.close(dialogueLogout);
++                    d.dialogShown = false;
++                }
++            }
++            Button {
++                text: "Yes"
++                onClicked: {
++                    DBusUnitySessionService.Logout();
++                    PopupUtils.close(dialogueLogout);
++                    d.dialogShown = false;
++                }
++            }
++        }
++    }
++
++    Component {
++        id: shutdownDialog
++        Dialog {
++            id: dialogueShutdown
++            title: "Shutdown"
++            text: "Are you sure that you want to shutdown?"
++            Button {
++                text: "Cancel"
++                onClicked: {
++                    PopupUtils.close(dialogueShutdown);
++                    d.dialogShown = false;
++                }
++            }
++            Button {
++                text: "Yes"
++                onClicked: {
++                    dBusUnitySessionServiceConnection.closeAllApps();
++                    DBusUnitySessionService.Shutdown();
++                    PopupUtils.close(dialogueShutdown);
++                    d.dialogShown = false;
++                }
++            }
++        }
++    }
++
++    Component {
++        id: rebootDialog
++        Dialog {
++            id: dialogueReboot
++            title: "Reboot"
++            text: "Are you sure that you want to reboot?"
++            Button {
++                text: "Cancel"
++                onClicked: {
++                    PopupUtils.close(dialogueReboot)
++                    d.dialogShown = false;
++                }
++            }
++            Button {
++                text: "Yes"
++                onClicked: {
++                    dBusUnitySessionServiceConnection.closeAllApps();
++                    DBusUnitySessionService.Reboot();
++                    PopupUtils.close(dialogueReboot);
++                    d.dialogShown = false;
++                }
++            }
++        }
++    }
++
++    Component {
++        id: powerDialog
++        Dialog {
++            id: dialoguePower
++            title: "Power"
++            text: i18n.tr("Are you sure you would like to turn power off?")
++            Button {
++                text: i18n.tr("Power off")
++                onClicked: {
++                    dBusUnitySessionServiceConnection.closeAllApps();
++                    PopupUtils.close(dialoguePower);
++                    d.dialogShown = false;
++                    root.powerOffClicked();
++                }
++            }
++            Button {
++                text: i18n.tr("Restart")
++                onClicked: {
++                    dBusUnitySessionServiceConnection.closeAllApps();
++                    DBusUnitySessionService.Reboot();
++                    PopupUtils.close(dialoguePower);
++                    d.dialogShown = false;
++                }
++            }
++            Button {
++                text: i18n.tr("Cancel")
++                onClicked: {
++                    PopupUtils.close(dialoguePower);
++                    d.dialogShown = false;
++                }
++            }
++        }
++    }
++
++
++    Connections {
++        id: dBusUnitySessionServiceConnection
++        objectName: "dBusUnitySessionServiceConnection"
++        target: DBusUnitySessionService
++
++        function closeAllApps() {
++            while (true) {
++                var app = ApplicationManager.get(0);
++                if (app === null) {
++                    break;
++                }
++                ApplicationManager.stopApplication(app.appId);
++            }
++        }
++
++        onLogoutRequested: {
++            // Display a dialog to ask the user to confirm.
++            if (!d.dialogShown) {
++                d.dialogShown = true;
++                PopupUtils.open(logoutDialog, root, {"z": root.z});
++            }
++        }
++
++        onShutdownRequested: {
++            // Display a dialog to ask the user to confirm.
++            if (!d.dialogShown) {
++                d.dialogShown = true;
++                PopupUtils.open(shutdownDialog, root, {"z": root.z});
++            }
++        }
++
++        onRebootRequested: {
++            // Display a dialog to ask the user to confirm.
++            if (!d.dialogShown) {
++                d.dialogShown = true;
++                PopupUtils.open(rebootDialog, root, {"z": root.z});
++            }
++        }
++
++        onLogoutReady: {
++            closeAllApps();
++            Qt.quit();
++        }
++    }
++
++}
 === modified file 'qml/Components/DraggingArea.qml'
 --- qml/Components/DraggingArea.qml	2013-10-25 14:26:29 +0000
 +++ qml/Components/DraggingArea.qml	2014-07-29 14:07:22 +0000
@@ -117,4 +117,8 @@
          dragging = false
          __pressedPosition = Qt.point(mouse.x, mouse.y)
+     }
++
++    onCanceled: {
++        dragging = false
++    }
+ }
 === added file 'qml/Components/InputMethod.qml'
 --- qml/Components/InputMethod.qml	1970-01-01 00:00:00 +0000
 +++ qml/Components/InputMethod.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,79 @@
++/*
++ * 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.0
++import Unity.Application 0.1
++import Ubuntu.Components 0.1
++
++Item {
++    id: root
++
++    property var surface: null
++
++    property int transitionDuration: UbuntuAnimation.FastDuration
++
++    state: {
++        if (surface && surface.state != MirSurfaceItem.Minimized) {
++            return "shown";
++        } else {
++            return "hidden";
++        }
++    }
++
++    states: [
++        State {
++            name: "shown"
++            PropertyChanges {
++                target: root
++                visible: true
++                y: 0
++            }
++        },
++        State {
++            name: "hidden"
++            PropertyChanges {
++                target: root
++                visible: false
++                // half-way down because the vkb occupies only the lower half of the surface
++                // TODO: consider keyboard rotation
++                y: root.parent.height / 2.0
++            }
++        }
++    ]
++
++    transitions: [
++        Transition {
++            from: "*"; to: "*"
++            PropertyAction { property: "visible"; value: true }
++            UbuntuNumberAnimation { property: "y"; duration: transitionDuration }
++        }
++    ]
++
++    onSurfaceChanged: {
++        if (surface) {
++            surface.parent = root;
++            surface.anchors.fill = root;
++        }
++    }
++
++    Component.onDestruction: {
++        if (surface) {
++            surface.parent = null;
++            surface.release();
++            surface = null;
++        }
++    }
++}
 === modified file 'qml/Components/PageHeader.qml'
 --- qml/Components/PageHeader.qml	2014-07-21 09:49:41 +0000
 +++ qml/Components/PageHeader.qml	2014-07-29 14:07:22 +0000
@@ -117,7 +117,7 @@
      Flickable {
          id: headerContainer
          objectName: "headerContainer"
--        clip: true
++        clip: openSearchAnimation.running
          anchors { left: parent.left; top: parent.top; right: parent.right }
          height: units.gu(6.5)
          contentHeight: headersColumn.height
@@ -155,6 +155,7 @@
                  anchors { left: parent.left; right: parent.right }
                  height: headerContainer.height
                  contentHeight: height
++                opacity: headerContainer.clip || headerContainer.showSearch ? 1 : 0 // setting visible false cause column to relayout
                  separatorSource: ""
                  // Required to keep PageHeadStyle noise down as it expects the Page's properties around.
                  property var styledItem: searchHeader
@@ -229,6 +230,7 @@
                  anchors { left: parent.left; right: parent.right }
                  height: headerContainer.height
                  contentHeight: height
++                opacity: headerContainer.clip || !headerContainer.showSearch ? 1 : 0 // setting visible false cause column to relayout
                  separatorSource: ""
                  textColor: root.scopeStyle ? root.scopeStyle.headerForeground : "grey"
                  property var styledItem: header
 === modified file 'qml/Dash/Apps/RunningApplicationTile.qml'
 --- qml/Dash/Apps/RunningApplicationTile.qml	2014-03-25 11:34:34 +0000
 +++ qml/Dash/Apps/RunningApplicationTile.qml	2014-07-29 14:07:22 +0000
@@ -29,11 +29,8 @@
      signal requestedActivationMode()
      signal requestedTerminationMode()
--    // Was: childrenRect.height
--    // To avoid "binding loop" warning
--    height: shapedApplicationImage.height + labelContainer.height
--
--    width: shapedApplicationImage.width <= units.gu(11) ? units.gu(11) : height
++    width: thumbnail.width
++    height: thumbnail.height + labelContainer.height
      property bool terminationModeEnabled: false
@@ -50,42 +47,53 @@
+         }
+     }
--    UbuntuShape {
--        id: shapedApplicationImage
--        anchors { top: parent.top; horizontalCenter: parent.horizontalCenter }
--
--        height: units.gu(17)
--        width: applicationImage.width
--        radius: "medium"
--
--        image: Image {
--            id: applicationImage
--            source: application.screenshot
--            // height : width = ss.height : ss.width
--            height: shapedApplicationImage.height
--            fillMode: Image.PreserveAspectCrop
--            width: Math.min(height, height * sourceSize.width / sourceSize.height)
--        }
--
--    }
--
--    UbuntuShape {
--        id: borderPressed
--
--        anchors.fill: shapedApplicationImage
--        radius: "medium"
--        borderSource: "radius_pressed.sci"
--        opacity: root.pressed ? 1.0 : 0.0
--        Behavior on opacity { NumberAnimation { duration: 200; easing.type: Easing.OutQuint } }
++    Item {
++        id: thumbnail
++
++        width: shapedApplicationImage.width
++        height: shapedApplicationImage.height
++
++        UbuntuShape {
++            id: shapedApplicationImage
++            x: 0
++            y: 0
++            height: applicationImage.height
++            width: applicationImage.width
++            radius: "medium"
++
++            image: Image {
++                id: applicationImage
++                source: application.screenshot
++                // height : width = ss.height : ss.width
++
++                property bool isLandscape: sourceSize.width > sourceSize.height
++                property real maxDimension: units.gu(17)
++
++                width: isLandscape ? Math.min(sourceSize.width, maxDimension) : height * (sourceSize.width / sourceSize.height)
++                height: isLandscape ? width * (sourceSize.height / sourceSize.width) : Math.min(sourceSize.height, maxDimension)
++                fillMode: Image.Stretch
++            }
++
++        }
++
++        UbuntuShape {
++            id: borderPressed
++
++            anchors.fill: shapedApplicationImage
++            radius: "medium"
++            borderSource: "radius_pressed.sci"
++            opacity: root.pressed ? 1.0 : 0.0
++            Behavior on opacity { NumberAnimation { duration: 200; easing.type: Easing.OutQuint } }
++        }
+     }
      // FIXME: label code duplicated with Tile
      Item {
          id: labelContainer
          anchors {
--            left: parent.left
--            right: parent.right
--            top: shapedApplicationImage.bottom
++            left: thumbnail.left
++            right: thumbnail.right
++            top: thumbnail.bottom
+         }
          height: units.gu(2)
@@ -110,9 +118,9 @@
      CloseIcon {
          objectName: "closeIcon " + model.name
          anchors {
--            left: shapedApplicationImage.left
++            left: thumbnail.left
              leftMargin: -units.gu(1)
--            top: parent.top
++            top: thumbnail.top
              topMargin: -units.gu(1)
+         }
          height: units.gu(6)
 === modified file 'qml/Dash/DashContent.qml'
 --- qml/Dash/DashContent.qml	2014-07-08 19:35:59 +0000
 +++ qml/Dash/DashContent.qml	2014-07-29 14:07:22 +0000
@@ -121,6 +121,10 @@
                  Loader {
                      width: ListView.view.width
                      height: ListView.view.height
++                    opacity: { // hide delegate if offscreen
++                        var xPositionRelativetoView = ListView.view.contentX - x
++                        return (xPositionRelativetoView > -width && xPositionRelativetoView < width) ? 1 : 0
++                    }
                      asynchronous: true
                      // TODO This if will eventually go away since we're killing DashApps.qml
                      // once we move app closing to the spread
 === added file 'qml/Dash/graphics/phone/screenshots/vkb_portrait.png'
 Binary files qml/Dash/graphics/phone/screenshots/vkb_portrait.png	1970-01-01 00:00:00 +0000 and qml/Dash/graphics/phone/screenshots/vkb_portrait.png	2014-07-29 14:07:22 +0000 differ
 === modified file 'qml/Launcher/Launcher.qml'
 --- qml/Launcher/Launcher.qml	2014-07-09 13:38:07 +0000
 +++ qml/Launcher/Launcher.qml	2014-07-29 14:07:22 +0000
@@ -181,7 +181,7 @@
              bottom: parent.bottom
+         }
          x: -width
--        opacity: (x == -width && dragArea.status === DirectionalDragArea.WaitingForTouch) ? 0 : 1
++        visible: x > -width || dragArea.status === DirectionalDragArea.Undecided
          model: LauncherModel
          property bool animate: true
 === modified file 'qml/Panel/Indicators.qml'
 --- qml/Panel/Indicators.qml	2014-07-10 13:36:41 +0000
 +++ qml/Panel/Indicators.qml	2014-07-29 14:07:22 +0000
@@ -37,6 +37,7 @@
      readonly property int lockThreshold: openedHeight / 2
      property bool fullyOpened: height == openedHeight
      property bool partiallyOpened: height > panelHeight && !fullyOpened
++    property bool fullyClosed: height <= panelHeight
      property bool contentEnabled: true
      property bool initalizeItem: true
      readonly property alias content: menuContent
@@ -187,6 +188,7 @@
              bottom: handle.top
+         }
          indicatorsModel: visibleIndicators.model
++        visible: indicators.partiallyOpened || indicators.fullyOpened
          clip: !indicators.fullyOpened
          activeHeader: indicators.state == "hint" || indicators.state == "reveal"
          enabled: contentEnabled
@@ -219,6 +221,7 @@
+         }
          height: Math.max(Math.min(handleImage.height, indicators.height - handleImage.height), 0)
          clip: height < handleImage.height
++        visible: menuContent.visible
          BorderImage {
              id: handleImage
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2014-07-18 15:13:35 +0000
 +++ qml/Shell.qml	2014-07-29 14:07:22 +0000
@@ -19,9 +19,9 @@
  import GSettings 1.0
  import Unity.Application 0.1
  import Ubuntu.Components 0.1
--import Ubuntu.Components.Popups 0.1
  import Ubuntu.Gestures 0.1
  import Unity.Launcher 0.1
++import Utils 0.1
  import LightDM 0.1 as LightDM
  import Powerd 0.1
  import SessionBroadcast 0.1
@@ -31,10 +31,11 @@
  import "Panel"
  import "Components"
  import "Notifications"
++import "Stages"
  import Unity.Notifications 1.0 as NotificationBackend
  import Unity.Session 0.1
--FocusScope {
++Item {
      id: shell
      // this is only here to select the width / height of the window if not running fullscreen
@@ -47,7 +48,7 @@
      property url background
      readonly property real panelHeight: panel.panelHeight
--    property bool dashShown: dash.shown
++    property bool dashShown: dash.shown && dash.available && underlay.visible
      property bool sideStageEnabled: shell.width >= units.gu(100)
      readonly property string focusedApplicationId: ApplicationManager.focusedApplicationId
@@ -55,14 +56,10 @@
      function activateApplication(appId) {
          if (ApplicationManager.findApplication(appId)) {
              ApplicationManager.requestFocusApplication(appId);
--            stages.show(true);
--            if (stages.locked && ApplicationManager.focusedApplicationId == appId) {
--                applicationsDisplayLoader.item.select(appId);
--            }
          } else {
              var execFlags = shell.sideStageEnabled ? ApplicationManager.NoFlag : ApplicationManager.ForceMainStage;
              ApplicationManager.startApplication(appId, execFlags);
--            stages.show(false);
++            stages.show();
+         }
+     }
@@ -89,82 +86,74 @@
          id: volumeControl
+     }
--    Keys.onVolumeUpPressed: volumeControl.volumeUp()
--    Keys.onVolumeDownPressed: volumeControl.volumeDown()
++    WindowKeysFilter {
++        // Handle but do not filter out volume keys
++        Keys.onVolumeUpPressed: { volumeControl.volumeUp(); event.accepted = false; }
++        Keys.onVolumeDownPressed: { volumeControl.volumeDown(); event.accepted = false; }
++
++        Keys.onPressed: {
++            if (event.key == Qt.Key_PowerOff || event.key == Qt.Key_PowerDown) {
++                dialogs.onPowerKeyPressed();
++                event.accepted = true;
++            } else {
++                event.accepted = false;
++            }
++        }
++
++        Keys.onReleased: {
++            if (event.key == Qt.Key_PowerOff || event.key == Qt.Key_PowerDown) {
++                dialogs.onPowerKeyReleased();
++                event.accepted = true;
++            } else {
++                event.accepted = false;
++            }
++        }
++    }
      Item {
--        id: underlayClipper
++        id: underlay
++        objectName: "underlay"
          anchors.fill: parent
--        anchors.rightMargin: stages.overlayWidth
--        clip: stages.overlayMode && !stages.painting
--
--        InputFilterArea {
--            anchors.fill: parent
--            blockInput: parent.clip
++
++        // Whether the underlay is fully covered by opaque UI elements.
++        property bool fullyCovered: (panel.indicators.fullyOpened && shell.width <= panel.indicatorsMenuWidth)
++                                        || stages.fullyShown || greeterWrapper.fullyShown
++        visible: !fullyCovered
++
++        Image {
++            anchors.fill: dash
++            source: shell.width > shell.height ? "Dash/graphics/paper_landscape.png" : "Dash/graphics/paper_portrait.png"
++            fillMode: Image.PreserveAspectCrop
++            horizontalAlignment: Image.AlignRight
++            verticalAlignment: Image.AlignTop
+         }
--        Item {
--            id: underlay
--            objectName: "underlay"
--            anchors.fill: parent
--            anchors.rightMargin: -parent.anchors.rightMargin
--
--            // Whether the underlay is fully covered by opaque UI elements.
--            property bool fullyCovered: panel.indicators.fullyOpened && shell.width <= panel.indicators.width
--
--            // Whether the user should see the topmost application surface (if there's one at all).
--            readonly property bool applicationSurfaceShouldBeSeen: stages.shown && !stages.painting && !stages.overlayMode
--
--            // NB! Application surfaces are stacked behind the shell one. So they can only be seen by the user
--            // through the translucent parts of the shell surface.
--            visible: !fullyCovered && !applicationSurfaceShouldBeSeen
--
--            Rectangle {
--                anchors.fill: parent
--                color: "black"
--                opacity: dash.disappearingAnimationProgress
--            }
--
--            Image {
--                anchors.fill: dash
--                source: shell.width > shell.height ? "Dash/graphics/paper_landscape.png" : "Dash/graphics/paper_portrait.png"
--                fillMode: Image.PreserveAspectCrop
--                horizontalAlignment: Image.AlignRight
--                verticalAlignment: Image.AlignTop
--            }
--
--            Dash {
--                id: dash
--                objectName: "dash"
--
--                available: !LightDM.Greeter.active
--                hides: [stages, launcher, panel.indicators]
--                shown: disappearingAnimationProgress !== 1.0 && greeterWrapper.showProgress !== 1.0
--                enabled: disappearingAnimationProgress === 0.0 && greeterWrapper.showProgress === 0.0 && edgeDemo.dashEnabled
--
--                anchors {
--                    fill: parent
--                    topMargin: panel.panelHeight
--                }
--
--                contentScale: 1.0 - 0.2 * disappearingAnimationProgress
--                opacity: 1.0 - disappearingAnimationProgress
--                property real disappearingAnimationProgress: {
--                    if (stages.overlayMode) {
--                        return 0;
--                    } else {
--                        return stages.showProgress
--                    }
--                }
--
--                // FIXME: only necessary because stages.showProgress is not animated
--                Behavior on disappearingAnimationProgress { SmoothedAnimation { velocity: 5 }}
--            }
++        Dash {
++            id: dash
++            objectName: "dash"
++
++            available: !LightDM.Greeter.active
++            hides: [stages, launcher, panel.indicators]
++            shown: disappearingAnimationProgress !== 1.0 && greeterWrapper.showProgress !== 1.0 &&
++                   !(panel.indicators.fullyOpened && !sideStageEnabled)
++            enabled: disappearingAnimationProgress === 0.0 && greeterWrapper.showProgress === 0.0 && edgeDemo.dashEnabled
++
++            anchors {
++                fill: parent
++                topMargin: panel.panelHeight
++            }
++
++            contentScale: 1.0 - 0.2 * disappearingAnimationProgress
++            opacity: 1.0 - disappearingAnimationProgress
++            property real disappearingAnimationProgress: stages.showProgress
++
++            // FIXME: only necessary because stages.showProgress is not animated
++            Behavior on disappearingAnimationProgress { SmoothedAnimation { velocity: 5 }}
+         }
+     }
      EdgeDragArea {
--        id: stagesDragHandle
++        id: stagesDragArea
          direction: Direction.Leftwards
          anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
@@ -174,20 +163,20 @@
          onTouchXChanged: {
              if (status == DirectionalDragArea.Recognized) {
--                if (ApplicationManager.count == 0) {
--                    progress = Math.max(stages.width - stagesDragHandle.width + touchX, stages.width * .3)
++                if (ApplicationManager.empty) {
++                    progress = Math.max(stages.width - stagesDragArea.width + touchX, stages.width * .3);
                  } else {
--                    progress = stages.width - stagesDragHandle.width + touchX
++                    progress = stages.width - stagesDragArea.width + touchX;
+                 }
+             }
+         }
          onDraggingChanged: {
              if (!dragging) {
--                if (ApplicationManager.count > 0 && progress < stages.width - units.gu(10)) {
--                    stages.show(true)
++                if (!ApplicationManager.empty && progress < stages.width - units.gu(10)) {
++                    stages.show();
+                 }
--                stagesDragHandle.progress = stages.width;
++                stagesDragArea.progress = Qt.binding(function () { return stages.width; });
+             }
+         }
+     }
@@ -198,253 +187,93 @@
          width: parent.width
          height: parent.height
++        visible: !fullyHidden && !ApplicationManager.empty
++
          x: {
              if (shown) {
--                if (overlayMode || locked || greeter.fakeActiveForApp !== "") {
++                if (locked || greeter.fakeActiveForApp !== "") {
                      return 0;
+                 }
--                return launcher.progress
++                return launcher.progress;
              } else {
--                return stagesDragHandle.progress
++                return stagesDragArea.progress
+             }
+         }
--
          Behavior on x { SmoothedAnimation { velocity: 600; duration: UbuntuAnimation.FastDuration } }
          property bool shown: false
++        onShownChanged: {
++            if (shown) {
++                if (ApplicationManager.count > 0) {
++                    ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
++                }
++            } else {
++                if (ApplicationManager.focusedApplicationId) {
++                    ApplicationManager.updateScreenshot(ApplicationManager.focusedApplicationId);
++                    ApplicationManager.unfocusCurrentApplication();
++                }
++            }
++        }
--        property real showProgress: overlayMode ? 0 : MathUtils.clamp(1 - x / shell.width, 0, 1)
++        // Avoid a silent "divide by zero -> NaN" situation during init as shell.width will be
++        // zero. That breaks the property binding and the function won't be reevaluated once
++        // shell.width is set, with the NaN result staying there for good.
++        property real showProgress: shell.width ? MathUtils.clamp(1 - x / shell.width, 0, 1) : 0
          property bool fullyShown: x == 0
          property bool fullyHidden: x == width
--        property bool painting: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.painting : false
--        property bool fullscreen: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.fullscreen : false
--        property bool overlayMode: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.overlayMode : false
--        property int overlayWidth: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.overlayWidth : false
          property bool locked: applicationsDisplayLoader.item ? applicationsDisplayLoader.item.locked : false
--        function show(focusApp) {
++        // It might technically not be fullyShown but visually it just looks so.
++        property bool roughlyFullyShown: x >= 0 && x <= units.gu(1)
++
++        function show() {
              shown = true;
--            panel.indicators.hide();
--            edgeDemo.stopDemo();
--            greeter.hide();
--            if (!ApplicationManager.focusedApplicationId && ApplicationManager.count > 0 && focusApp) {
--                ApplicationManager.focusApplication(ApplicationManager.get(0).appId);
--            }
+         }
          function hide() {
              shown = false;
--            if (ApplicationManager.focusedApplicationId) {
--                ApplicationManager.unfocusCurrentApplication();
--            }
+         }
          Connections {
              target: ApplicationManager
--
              onFocusRequested: {
                  if (greeter.fakeActiveForApp !== "" && greeter.fakeActiveForApp !== appId) {
                      lockscreen.show();
+                 }
                  greeter.hide();
--                stages.show(true);
++                stages.show();
+             }
              onFocusedApplicationIdChanged: {
                  if (greeter.fakeActiveForApp !== "" && greeter.fakeActiveForApp !== ApplicationManager.focusedApplicationId) {
                      lockscreen.show();
+                 }
--                if (ApplicationManager.focusedApplicationId.length > 0) {
--                    stages.show(false);
--                } else {
--                    if (!stages.overlayMode) {
--                        stages.hide();
--                    }
--                }
++                panel.indicators.hide();
+             }
              onApplicationAdded: {
--                stages.show(false);
++                if (greeter.shown) {
++                    greeter.hide();
++                }
++                if (!stages.shown) {
++                    stages.show();
++                }
+             }
--            onApplicationRemoved: {
--                if (ApplicationManager.focusedApplicationId.length == 0) {
++            onEmptyChanged: {
++                if (ApplicationManager.empty) {
                      stages.hide();
+                 }
+             }
+         }
--        property bool dialogShown: false
--
--        Component {
--            id: logoutDialog
--            Dialog {
--                id: dialogueLogout
--                title: "Logout"
--                text: "Are you sure that you want to logout?"
--                Button {
--                    text: "Cancel"
--                    onClicked: {
--                        PopupUtils.close(dialogueLogout);
--                        stages.dialogShown = false;
--                    }
--                }
--                Button {
--                    text: "Yes"
--                    onClicked: {
--                        DBusUnitySessionService.Logout();
--                        PopupUtils.close(dialogueLogout);
--                        stages.dialogShown = false;
--                    }
--                }
--            }
--        }
--
--        Component {
--            id: shutdownDialog
--            Dialog {
--                id: dialogueShutdown
--                title: "Shutdown"
--                text: "Are you sure that you want to shutdown?"
--                Button {
--                    text: "Cancel"
--                    onClicked: {
--                        PopupUtils.close(dialogueShutdown);
--                        stages.dialogShown = false;
--                    }
--                }
--                Button {
--                    text: "Yes"
--                    onClicked: {
--                        dBusUnitySessionServiceConnection.closeAllApps();
--                        DBusUnitySessionService.Shutdown();
--                        PopupUtils.close(dialogueShutdown);
--                        stages.dialogShown = false;
--                    }
--                }
--            }
--        }
--
--        Component {
--            id: rebootDialog
--            Dialog {
--                id: dialogueReboot
--                title: "Reboot"
--                text: "Are you sure that you want to reboot?"
--                Button {
--                    text: "Cancel"
--                    onClicked: {
--                        PopupUtils.close(dialogueReboot)
--                        stages.dialogShown = false;
--                    }
--                }
--                Button {
--                    text: "Yes"
--                    onClicked: {
--                        dBusUnitySessionServiceConnection.closeAllApps();
--                        DBusUnitySessionService.Reboot();
--                        PopupUtils.close(dialogueReboot);
--                        stages.dialogShown = false;
--                    }
--                }
--            }
--        }
--
--        Component {
--            id: powerDialog
--            Dialog {
--                id: dialoguePower
--                title: "Power"
--                text: i18n.tr("Are you sure you would like to turn power off?")
--                Button {
--                    text: i18n.tr("Power off")
--                    onClicked: {
--                        dBusUnitySessionServiceConnection.closeAllApps();
--                        PopupUtils.close(dialoguePower);
--                        stages.dialogShown = false;
--                        shutdownFadeOutRectangle.enabled = true;
--                        shutdownFadeOutRectangle.visible = true;
--                        shutdownFadeOut.start();
--                    }
--                }
--                Button {
--                    text: i18n.tr("Restart")
--                    onClicked: {
--                        dBusUnitySessionServiceConnection.closeAllApps();
--                        DBusUnitySessionService.Reboot();
--                        PopupUtils.close(dialoguePower);
--                        stages.dialogShown = false;
--                    }
--                }
--                Button {
--                    text: i18n.tr("Cancel")
--                    onClicked: {
--                        PopupUtils.close(dialoguePower);
--                        stages.dialogShown = false;
--                    }
--                }
--            }
--        }
--
--        function showPowerDialog() {
--            if (!stages.dialogShown) {
--                stages.dialogShown = true;
--                PopupUtils.open(powerDialog);
--            }
--        }
--
--        Connections {
--            id: dBusUnitySessionServiceConnection
--            objectName: "dBusUnitySessionServiceConnection"
--            target: DBusUnitySessionService
--
--            function closeAllApps() {
--                while (true) {
--                    var app = ApplicationManager.get(0);
--                    if (app === null) {
--                        break;
--                    }
--                    ApplicationManager.stopApplication(app.appId);
--                }
--            }
--
--            onLogoutRequested: {
--                // Display a dialog to ask the user to confirm.
--                if (!stages.dialogShown) {
--                    stages.dialogShown = true;
--                    PopupUtils.open(logoutDialog);
--                }
--            }
--
--            onShutdownRequested: {
--                // Display a dialog to ask the user to confirm.
--                if (!stages.dialogShown) {
--                    stages.dialogShown = true;
--                    PopupUtils.open(shutdownDialog);
--                }
--            }
--
--            onRebootRequested: {
--                // Display a dialog to ask the user to confirm.
--                if (!stages.dialogShown) {
--                    stages.dialogShown = true;
--                    PopupUtils.open(rebootDialog);
--                }
--            }
--
--            onLogoutReady: {
--                closeAllApps();
--                Qt.quit();
--            }
--        }
--
          Loader {
              id: applicationsDisplayLoader
              anchors.fill: parent
--            source: shell.sideStageEnabled ? "Stages/StageWithSideStage.qml" : "Stages/PhoneStage.qml"
++            source: shell.sideStageEnabled ? "Stages/TabletStage.qml" : "Stages/PhoneStage.qml"
              Binding {
                  target: applicationsDisplayLoader.item
@@ -453,27 +282,56 @@
+             }
              Binding {
                  target: applicationsDisplayLoader.item
--                property: "moving"
--                value: !stages.fullyShown
--            }
--            Binding {
--                target: applicationsDisplayLoader.item
--                property: "shown"
--                value: stages.shown
--            }
--            Binding {
--                target: applicationsDisplayLoader.item
                  property: "dragAreaWidth"
                  value: shell.edgeSize
+             }
              Binding {
                  target: applicationsDisplayLoader.item
++                property: "maximizedAppTopMargin"
++                // Not just using panel.panelHeight as that changes depending on the focused app.
++                value: panel.indicators.panelHeight
++            }
++            Binding {
++                target: applicationsDisplayLoader.item
++                property: "interactive"
++                value: stages.roughlyFullyShown && !greeter.shown && !lockscreen.shown
++                       && panel.indicators.fullyClosed
++            }
++            Binding {
++                target: applicationsDisplayLoader.item
                  property: "spreadEnabled"
                  value: greeter.fakeActiveForApp === "" // to support emergency dialer hack
+             }
+         }
+     }
++    InputMethod {
++        id: inputMethod
++        objectName: "inputMethod"
++        anchors { fill: parent; topMargin: panel.panelHeight }
++        z: notifications.useModal || panel.indicators.shown ? overlay.z + 1 : overlay.z - 1
++    }
++
++    Connections {
++        target: SurfaceManager
++        onSurfaceCreated: {
++            if (surface.type == MirSurfaceItem.InputMethod) {
++                inputMethod.surface = surface;
++            }
++        }
++
++        onSurfaceDestroyed: {
++            if (inputMethod.surface == surface) {
++                inputMethod.surface = null;
++                surface.parent = null;
++            }
++            if (!surface.parent) {
++                // there's no one displaying it. delete it right away
++                surface.release();
++            }
++        }
++    }
++
      Lockscreen {
          id: lockscreen
          objectName: "lockscreen"
@@ -486,7 +344,7 @@
          showAnimation: StandardAnimation { property: "opacity"; to: 1 }
          hideAnimation: StandardAnimation { property: "opacity"; to: 0 }
          y: panel.panelHeight
--        x: required ? 0 : - width
++        visible: required
          width: parent.width
          height: parent.height - panel.panelHeight
          background: shell.background
@@ -566,6 +424,7 @@
              StandardAnimation {}
+         }
++        property bool fullyShown: showProgress === 1.0
          readonly property real showProgress: MathUtils.clamp((1 - x/width) + greeter.showProgress - 1, 0, 1)
          onShowProgressChanged: if (LightDM.Greeter.promptless && showProgress === 0) greeter.login()
@@ -632,12 +491,6 @@
+         }
+     }
--    InputFilterArea {
--        anchors.fill: parent
--        blockInput: ApplicationManager.focusedApplicationId.length === 0 || greeter.shown || lockscreen.shown || launcher.shown
--                    || panel.indicators.shown
--    }
--
      Connections {
          id: powerConnection
          target: Powerd
@@ -680,7 +533,7 @@
              return;
+         }
--        if (stages.shown && !stages.overlayMode && !stages.locked) {
++        if (!stages.locked) {
              stages.hide();
              launcher.fadeOut();
          } else {
@@ -695,6 +548,7 @@
      Item {
          id: overlay
++        z: 10
          anchors.fill: parent
@@ -709,29 +563,13 @@
                  width: parent.width > units.gu(60) ? units.gu(40) : parent.width
                  panelHeight: units.gu(3)
+             }
--            property string focusedAppId: ApplicationManager.focusedApplicationId
--            property var focusedApplication: ApplicationManager.findApplication(focusedAppId)
--            fullscreenMode: (focusedApplication && stages.fullscreen && !LightDM.Greeter.active) || greeter.fakeActiveForApp !== ""
--
--            InputFilterArea {
--                anchors {
--                    top: parent.top
--                    left: parent.left
--                    right: parent.right
--                }
--                height: (panel.fullscreenMode) ? shell.edgeSize : panel.panelHeight
--                blockInput: true
--            }
--        }
--
--        InputFilterArea {
--            blockInput: launcher.shown
--            anchors {
--                top: parent.top
--                bottom: parent.bottom
--                left: parent.left
--            }
--            width: launcher.width
++
++            property bool topmostApplicationIsFullscreen:
++                ApplicationManager.focusedApplicationId &&
++                    ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).fullscreen
++
++            fullscreenMode: (stages.roughlyFullyShown && topmostApplicationIsFullscreen
++                    && !LightDM.Greeter.active) || greeter.fakeActiveForApp !== ""
+         }
          Launcher {
@@ -774,11 +612,6 @@
              MouseArea {
                  anchors.fill: parent
+             }
--
--            InputFilterArea {
--                anchors.fill: parent
--                blockInput: modalNotificationBackground.visible
--            }
+         }
          Notifications {
@@ -804,36 +637,7 @@
                      PropertyChanges { target: notifications; width: units.gu(38) }
+                 }
+             ]
--
--            InputFilterArea {
--                anchors { left: parent.left; right: parent.right }
--                height: parent.contentHeight
--                blockInput: height > 0
--            }
--        }
--    }
--
--    focus: true
--    onFocusChanged: if (!focus) forceActiveFocus();
--
--    InputFilterArea {
--        anchors {
--            top: parent.top
--            bottom: parent.bottom
--            left: parent.left
--        }
--        width: shell.edgeSize
--        blockInput: true
--    }
--
--    InputFilterArea {
--        anchors {
--            top: parent.top
--            bottom: parent.bottom
--            right: parent.right
--        }
--        width: shell.edgeSize
--        blockInput: true
++        }
+     }
      Binding {
@@ -842,24 +646,22 @@
          value: "unity8"
+     }
--    OSKController {
--        anchors.topMargin: panel.panelHeight
--        anchors.fill: parent // as needs to know the geometry of the shell
--    }
--
--    //FIXME: This should be handled in the input stack, keyboard shouldnt propagate
--    MouseArea {
--        anchors.bottom: parent.bottom
--        anchors.left: parent.left
--        anchors.right: parent.right
--        height: ApplicationManager.keyboardVisible ? ApplicationManager.keyboardHeight : 0
--
--        enabled: ApplicationManager.keyboardVisible
++    Dialogs {
++        id: dialogs
++        anchors.fill: parent
++        z: overlay.z + 10
++        onPowerOffClicked: {
++            shutdownFadeOutRectangle.enabled = true;
++            shutdownFadeOutRectangle.visible = true;
++            shutdownFadeOut.start();
++        }
+     }
      Label {
++        id: alphaDisclaimerLabel
          anchors.centerIn: parent
          visible: ApplicationManager.fake ? ApplicationManager.fake : false
++        z: dialogs.z + 10
          text: "EARLY ALPHA\nNOT READY FOR USE"
          color: "lightgrey"
          opacity: 0.2
@@ -873,6 +675,7 @@
      EdgeDemo {
          id: edgeDemo
++        z: alphaDisclaimerLabel.z + 10
          greeter: greeter
          launcher: launcher
          dash: dash
@@ -885,35 +688,9 @@
          onShowHome: showHome()
+     }
--    Keys.onPressed: {
--        if (event.key == Qt.Key_PowerOff || event.key == Qt.Key_PowerDown) {
--            if (!powerKeyTimer.running) {
--                powerKeyTimer.start();
--            }
--            event.accepted = true;
--        }
--    }
--
--    Keys.onReleased: {
--        if (event.key == Qt.Key_PowerOff || event.key == Qt.Key_PowerDown) {
--            powerKeyTimer.stop();
--            event.accepted = true;
--        }
--    }
--
--    Timer {
--        id: powerKeyTimer
--        interval: 2000
--        repeat: false
--        triggeredOnStart: false
--
--        onTriggered: {
--            stages.showPowerDialog();
--        }
--    }
--
      Rectangle {
          id: shutdownFadeOutRectangle
++        z: edgeDemo.z + 10
          enabled: false
          visible: false
          color: "black"
@@ -930,4 +707,5 @@
+             }
+         }
+     }
++
+ }
 === added directory 'qml/Stages/Animations'
 === added file 'qml/Stages/Animations/BaseSurfaceAnimation.qml'
 --- qml/Stages/Animations/BaseSurfaceAnimation.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/Animations/BaseSurfaceAnimation.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,93 @@
++/*
++ * 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.0
++
++/* 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 Item surface: null
++
++    // changes applied when state changes to "in"
++    property list<QtObject> outChanges
++    // transition animations when changing state to "in"
++    property list<QtObject> outAnimations
++
++    // changes applied when state changes to "out"
++    property list<QtObject> inChanges
++    // transition animations when changing state to "out"
++    property list<QtObject> inAnimations
++
++    function start() {
++        // "prep" state forces outChanges without transition animations.
++        state = "prep"
++        state = "in";
++    }
++    function end() {
++        state = "out";
++    }
++
++    states: [
++        State {
++            name: "baseAnimation"
++            PropertyChanges { target: base.surface; anchors.fill: undefined }
++        },
++
++        State {
++            name: "prep"
++            extend: "baseAnimation"
++            changes: outChanges
++        },
++        State {
++            name: "out"
++            extend: "prep"
++        },
++        State {
++            name: "in"
++            extend: "baseAnimation"
++            changes: inChanges
++        }
++    ]
++
++    transitions: [
++        Transition {
++            to:  "out"
++            animations: outAnimations
++        },
++        Transition {
++            to: "in"
++            animations: inAnimations
++        }
++    ]
++}
 === added file 'qml/Stages/Animations/DarkenAndFadeInAnimation.qml'
 --- qml/Stages/Animations/DarkenAndFadeInAnimation.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/Animations/DarkenAndFadeInAnimation.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,48 @@
++/*
++ * 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.0
++import Ubuntu.Components 1.1
++
++BaseSurfaceAnimation {
++    id: animation
++
++    property Rectangle darkenItem: Rectangle {
++        parent: animation.surface.parent
++        anchors.fill: parent
++        color: Qt.rgba(0,0,0,0.0)
++    }
++
++    outChanges: [ PropertyChanges { target: animation.surface; opacity: 0.0 } ]
++    outAnimations: [
++        SequentialAnimation {
++            UbuntuNumberAnimation { target: animation.surface; property: "opacity"; duration: UbuntuAnimation.FastDuration }
++            ColorAnimation { target: darkenItem; duration: UbuntuAnimation.FastDuration }
++            ScriptAction { script: { if (animation.parent.removing) animation.surface.release(); } }
++        }
++    ]
++
++    inChanges: [
++        PropertyChanges { target: darkenItem; color: Qt.rgba(0,0,0,0.7) },
++        PropertyChanges { target: animation.surface; opacity: 1.0 }
++    ]
++    inAnimations: [
++        SequentialAnimation {
++            ColorAnimation { target: darkenItem; duration: UbuntuAnimation.FastDuration }
++            UbuntuNumberAnimation { target: animation.surface; property: "opacity"; duration: UbuntuAnimation.FastDuration }
++        }
++    ]
++}
 === added file 'qml/Stages/Animations/SwipeFromBottomAnimation.qml'
 --- qml/Stages/Animations/SwipeFromBottomAnimation.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/Animations/SwipeFromBottomAnimation.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,48 @@
++/*
++ * 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.0
++
++BaseSurfaceAnimation {
++    id: animation
++
++    outChanges: [ AnchorChanges { target: animation.surface; anchors.top: animation.parent.bottom } ]
++    outAnimations: [
++        SequentialAnimation {
++            PropertyAction { target: animation.parent; property: "clip"; value: true }
++            AnchorAnimation { easing.type: Easing.InOutQuad; duration: 400 }
++            PropertyAction { target: animation.surface; property: "visible"; value: !animation.parent.removing }
++            PropertyAction { target: animation.parent; property: "clip"; value: false }
++            ScriptAction { script: { if (animation.parent.removing) animation.surface.release(); } }
++        }
++    ]
++
++    inChanges: [
++        AnchorChanges {
++            target: animation.surface;
++            anchors.top: animation.parent.top
++            anchors.right: undefined
++            anchors.bottom: undefined
++            anchors.left: undefined
++        } ]
++    inAnimations: [
++        SequentialAnimation {
++            PropertyAction { target: animation.parent; property: "clip"; value: true }
++            AnchorAnimation { easing.type: Easing.InOutQuad; duration: 400 }
++            PropertyAction { target: animation.parent; property: "clip"; value: false }
++        }
++    ]
++}
 === added file 'qml/Stages/Animations/SwipeUpAnimation.qml'
 --- qml/Stages/Animations/SwipeUpAnimation.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/Animations/SwipeUpAnimation.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,49 @@
++/*
++ * 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.0
++
++BaseSurfaceAnimation {
++    id: animation
++
++    outAnimations: [
++        SequentialAnimation {
++            PropertyAction { target: animation.parent; property: "clip"; value: true }
++            PropertyAction { target: animation.surface; property: "visible"; value: true }
++            AnchorAnimation { easing.type: Easing.InOutQuad; duration: 400 }
++            PropertyAction { target: animation.parent; property: "clip"; value: false }
++            ScriptAction { script: { if (animation.parent.removing) animation.surface.release(); } }
++        }
++    ]
++
++    inChanges: [
++        AnchorChanges {
++            target: animation.surface;
++            anchors.top: undefined
++            anchors.right: undefined
++            anchors.bottom: animation.parent.top
++            anchors.left: undefined
++        }
++    ]
++    inAnimations: [
++        SequentialAnimation {
++            PropertyAction { target: animation.parent; property: "clip"; value: true }
++            AnchorAnimation { easing.type: Easing.InOutQuad; duration: 400 }
++            PropertyAction { target: animation.surface; property: "visible"; value: false}
++            PropertyAction { target: animation.parent; property: "clip"; value: false }
++        }
++    ]
++}
 === modified file 'qml/Stages/PhoneStage.qml'
 --- qml/Stages/PhoneStage.qml	2014-06-24 23:52:12 +0000
 +++ qml/Stages/PhoneStage.qml	2014-07-29 14:07:22 +0000
@@ -18,7 +18,6 @@
  import Ubuntu.Components 0.1
  import Ubuntu.Gestures 0.1
  import Unity.Application 0.1
--import LightDM 0.1 as LightDM
  import Utils 0.1
  import "../Components"
@@ -26,88 +25,51 @@
      id: root
      // Controls to be set from outside
--    property bool shown: false
--    property bool moving: false
      property int dragAreaWidth
++    property real maximizedAppTopMargin
++    property bool interactive
++    property bool spreadEnabled: true // If false, animations and right edge will be disabled
      // State information propagated to the outside
--    readonly property bool painting: mainScreenshotImage.visible || fadeInScreenshotImage.visible || appSplash.visible || spreadView.visible
--    property bool fullscreen: priv.focusedApplication ? priv.focusedApplication.fullscreen : false
--    property bool locked: spreadView.visible
--    property bool spreadEnabled: true
--
--    // Not used for PhoneStage, only useful for SideStage and similar
--    property bool overlayMode: false
--    property int overlayWidth: 0
++    readonly property bool locked: spreadView.phase == 2
      function select(appId) {
--        spreadView.snapTo(priv.indexOf(appId))
++        spreadView.snapTo(priv.indexOf(appId));
+     }
--    onMovingChanged: {
--        if (moving) {
--            if (ApplicationManager.focusedApplicationId) {
--                priv.requestNewScreenshot();
--            } else {
--                mainScreenshotImage.anchors.leftMargin = 0;
--                mainScreenshotImage.source = ApplicationManager.get(0).screenshot;
--                mainScreenshotImage.visible = true;
--            }
--        } else {
--            mainScreenshotImage.visible = false;
--        }
++    onWidthChanged: {
++        spreadView.selectedIndex = -1;
++        spreadView.phase = 0;
++        spreadView.contentX = -spreadView.shift;
+     }
      Connections {
          target: ApplicationManager
          onFocusRequested: {
--            if (spreadView.visible) {
++            if (spreadView.phase > 0) {
                  spreadView.snapTo(priv.indexOf(appId));
              } else {
                  priv.switchToApp(appId);
+             }
+         }
--        onFocusedApplicationIdChanged: {
--            if (ApplicationManager.focusedApplicationId.length > 0) {
--                if (priv.secondApplicationStarting || priv.applicationStarting) {
--                    appSplashTimer.restart();
--                } else {
--                    var application = priv.focusedApplication;
--                    root.fullscreen = application.fullscreen;
--                    mainScreenshotImage.source = application.screenshot;
--                }
--            } else {
--                spreadView.selectedIndex = -1;
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--            }
--        }
--
          onApplicationAdded: {
--            if (!priv.focusedApplication) {
--                mainScreenshotImage.source = "";
--                mainScreenshotImage.visible = false;
--                priv.applicationStarting = true;
++            if (spreadView.phase == 2) {
++                spreadView.snapTo(ApplicationManager.count - 1);
              } else {
--                mainScreenshotImage.source = "";
--                priv.newFocusedAppId = appId;
--                priv.secondApplicationStarting = true;
--                priv.requestNewScreenshot();
--            }
--
--            if (spreadView.visible) {
--                spreadView.snapTo(0);
++                spreadView.phase = 0;
++                spreadView.contentX = -spreadView.shift;
++                priv.switchToApp(appId);
+             }
+         }
          onApplicationRemoved: {
--            if (ApplicationManager.count == 0) {
--                mainScreenshotImage.source = ""
--                mainScreenshotImage.visible = false;
--            } else {
--                mainScreenshotImage.source = ApplicationManager.get(0).screenshot;
++            // 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;
+             }
+         }
+     }
@@ -117,46 +79,11 @@
          property string focusedAppId: ApplicationManager.focusedApplicationId
          property var focusedApplication: ApplicationManager.findApplication(focusedAppId)
--        property url focusedScreenshot: focusedApplication ? focusedApplication.screenshot : ""
--
--        property bool waitingForScreenshot: false
--
--        property bool applicationStarting: false
--        property bool secondApplicationStarting: false
--
--        property string newFocusedAppId
--
--        onFocusedScreenshotChanged: {
--            if (root.moving && priv.waitingForScreenshot) {
--                mainScreenshotImage.anchors.leftMargin = 0;
--                mainScreenshotImage.source = priv.focusedScreenshot
--                mainScreenshotImage.visible = true;
--            } else if (priv.secondApplicationStarting && priv.waitingForScreenshot) {
--                applicationSwitchingAnimation.start();
--                if (LightDM.Greeter.active && !LightDM.Greeter.promptless) {
--                    // When greeter is up, no fancy animations, since user may
--                    // glimpse an app they shouldn't
--                    applicationSwitchingAnimation.complete();
--                }
--            }
--            waitingForScreenshot = false;
--        }
--
--        function requestNewScreenshot() {
--            waitingForScreenshot = true;
--            ApplicationManager.updateScreenshot(focusedAppId);
--        }
          function switchToApp(appId) {
              if (priv.focusedAppId) {
--                priv.newFocusedAppId = appId;
--                root.fullscreen = ApplicationManager.findApplication(appId).fullscreen;
--                applicationSwitchingAnimation.start();
--                if (LightDM.Greeter.active && !LightDM.Greeter.promptless) {
--                    // When greeter is up, no fancy animations, since user may
--                    // glimpse an app they shouldn't
--                    applicationSwitchingAnimation.complete();
--                }
++                spreadView.focusChanging = true;
++                ApplicationManager.focusApplication(appId);
              } else {
                  ApplicationManager.focusApplication(appId);
+             }
@@ -173,158 +100,6 @@
+     }
--    // FIXME: the signal connections seems to get lost.
--    Connections {
--        target: priv.focusedApplication
--        onScreenshotChanged: priv.focusedScreenshot = priv.focusedApplication.screenshot
--    }
--    Binding {
--        target: root
--        property: "fullscreen"
--        value: priv.focusedApplication ? priv.focusedApplication.fullscreen : false
--    }
--
--    Timer {
--        id: appSplashTimer
--        // FIXME: We really need to show something meaningful in the app surface instead of guessing
--        // when it might be ready
--        interval: 500
--        repeat: false
--        onTriggered: {
--            priv.applicationStarting = false;
--            priv.secondApplicationStarting = false;
--        }
--    }
--
--    SequentialAnimation {
--        id: applicationSwitchingAnimation
--        // setup
--        PropertyAction { target: mainScreenshotImage; property: "anchors.leftMargin"; value: 0 }
--        PropertyAction { target: mainScreenshotImage; property: "source"; value: priv.focusedScreenshot }
--        PropertyAction { targets: [mainScreenshotImage, fadeInScreenshotImage]; property: "visible"; value: true }
--        PropertyAction { target: fadeInScreenshotImage; property: "source"; value: {
--                var newFocusedApp = ApplicationManager.findApplication(priv.newFocusedAppId);
--                return newFocusedApp ? newFocusedApp.screenshot : "" }
--        }
--        PropertyAction { target: fadeInScreenshotImage; property: "opacity"; value: 0 }
--        PropertyAction { target: fadeInScreenshotImage; property: "scale"; value: .8 }
--
--
--        // The actual animation
--        ParallelAnimation {
--            UbuntuNumberAnimation { target: mainScreenshotImage; property: "anchors.leftMargin"; to: root.width; duration: UbuntuAnimation.SlowDuration }
--            UbuntuNumberAnimation { target: fadeInScreenshotImage; properties: "opacity,scale"; to: 1; duration: UbuntuAnimation.SlowDuration }
--        }
--
--        // restore stuff
--        ScriptAction { script: ApplicationManager.focusApplication(priv.newFocusedAppId); }
--        PropertyAction { target: fadeInScreenshotImage; property: "visible"; value: false }
--        PropertyAction { target: mainScreenshotImage; property: "visible"; value: false }
--    }
--
--    // FIXME: Drop this and make the imageprovider show a splashscreen instead
--    Rectangle {
--        id: appSplash2
--        anchors.fill: parent
--        color: "black"
--        visible: priv.secondApplicationStarting
--    }
--    Image {
--        id: fadeInScreenshotImage
--        anchors { left: parent.left; bottom: parent.bottom }
--        width: parent.width
--        scale: .7
--        visible: false
--    }
--
--    Rectangle {
--        id: appSplash
--        anchors.fill: parent
--        color: "black"
--        visible: priv.applicationStarting
--
--        WaitingDots {
--        }
--    }
--    Image {
--        id: mainScreenshotImage
--        anchors { left: parent.left; bottom: parent.bottom }
--        width: parent.width
--        visible: false
--    }
--
--    EdgeDragArea {
--        id: spreadDragArea
--        direction: Direction.Leftwards
--        enabled: ApplicationManager.count > 1 && spreadView.phase != 2 && root.spreadEnabled
--
--        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
--        width: root.dragAreaWidth
--
--        // Sitting at the right edge of the screen, this EdgeDragArea directly controls the spreadView when
--        // attachedToView is true. When the finger movement passes positionMarker3 we detach it from the
--        // spreadView and make the spreadView snap to positionMarker4.
--        property bool attachedToView: true
--
--        property var gesturePoints: new Array()
--
--        onTouchXChanged: {
--            if (!dragging && !priv.waitingForScreenshot) {
--                // Initial touch. Let's update the screenshot and reset the spreadView to the starting position.
--                priv.requestNewScreenshot();
--                spreadView.phase = 0;
--                spreadView.contentX = -spreadView.shift;
--            }
--            if (dragging && attachedToView) {
--                // Gesture recognized. Let's move the spreadView with the finger
--                spreadView.contentX = -touchX - spreadView.shift;
--            }
--            if (attachedToView && spreadView.shiftedContentX >= spreadView.width * spreadView.positionMarker3) {
--                // We passed positionMarker3. Detach from spreadView and snap it.
--                attachedToView = false;
--                spreadView.snap();
--            }
--            gesturePoints.push(touchX);
--        }
--
--        onStatusChanged: {
--            if (status == DirectionalDragArea.Recognized) {
--                attachedToView = true;
--            }
--        }
--
--        onDraggingChanged: {
--            if (dragging) {
--                // Gesture recognized. Start recording this gesture
--                gesturePoints = [];
--                return;
--            }
--
--            // Ok. The user released. Find out if it was a one-way movement.
--            var oneWayFlick = true;
--            var smallestX = spreadDragArea.width;
--            for (var i = 0; i < gesturePoints.length; i++) {
--                if (gesturePoints[i] >= smallestX) {
--                    oneWayFlick = false;
--                    break;
--                }
--                smallestX = gesturePoints[i];
--            }
--            gesturePoints = [];
--
--            if (oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
--                    spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
--                // If it was a short one-way movement, do the Alt+Tab switch
--                // no matter if we didn't cross positionMarker1 yet.
--                spreadView.snapTo(1);
--            } else if (!dragging && attachedToView) {
--                // otherwise snap to the closest snap position we can find
--                // (might be back to start, to app 1 or to spread)
--                spreadView.snap();
--            }
--        }
--    }
--
      Rectangle {
          id: coverFlipBackground
          anchors.fill: parent
@@ -332,16 +107,12 @@
          visible: spreadView.visible
+     }
--    InputFilterArea {
--        anchors.fill: root
--        blockInput: spreadView.visible
--    }
      Flickable {
          id: spreadView
          objectName: "spreadView"
          anchors.fill: parent
--        visible: spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1 || snapAnimation.running
++        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1) && draggedIndex == -1
          contentWidth: spreadRow.width - shift
          contentX: -shift
@@ -350,8 +121,8 @@
          // that, the beginning of the gesture starts with a negative value for contentX
          // so the flickable wants to pull it into the view already. "shift" tunes the
          // distance where to "lock" the content.
--        property real shift: width / 2
--        property real shiftedContentX: contentX + shift
++        readonly property real shift: width / 2
++        readonly property real shiftedContentX: contentX + shift
          property int tileDistance: width / 4
@@ -375,6 +146,10 @@
          property int phase: 0
          property int selectedIndex: -1
++        property int draggedIndex: -1
++        property int closingIndex: -1
++
++        property bool focusChanging: false
          onShiftedContentXChanged: {
              switch (phase) {
@@ -398,9 +173,9 @@
                  snapAnimation.targetContentX = -shift;
                  snapAnimation.start();
              } else if (shiftedContentX < positionMarker2 * width) {
--                snapTo(1)
++                snapTo(1);
              } else if (shiftedContentX < positionMarker3 * width) {
--                snapTo(1)
++                snapTo(1);
              } else if (phase < 2){
                  // Add 1 pixel to make sure we definitely hit positionMarker4 even with rounding errors of the animation.
                  snapAnimation.targetContentX = width * positionMarker4 + 1 - shift;
@@ -408,9 +183,18 @@
+             }
+         }
          function snapTo(index) {
++            if (ApplicationManager.count <= index) {
++                // In case we're trying to snap to some non existing app, lets snap back to the first one
++                index = 0;
++            }
              spreadView.selectedIndex = index;
--            root.fullscreen = ApplicationManager.get(index).fullscreen;
--            snapAnimation.targetContentX = -shift;
++            // If we're not in full spread mode yet, always unwind to start pos
++            // otherwise unwind up to progress 0 of the selected index
++            if (spreadView.phase < 2) {
++                snapAnimation.targetContentX = -shift;
++            } else {
++                snapAnimation.targetContentX = -shift + index * spreadView.tileDistance;
++            }
              snapAnimation.start();
+         }
@@ -429,7 +213,8 @@
                  script: {
                      if (spreadView.selectedIndex >= 0) {
                          ApplicationManager.focusApplication(ApplicationManager.get(spreadView.selectedIndex).appId);
--                        spreadView.selectedIndex = -1
++
++                        spreadView.selectedIndex = -1;
                          spreadView.phase = 0;
                          spreadView.contentX = -spreadView.shift;
+                     }
@@ -443,6 +228,15 @@
              //  tileDistance * app count (with a minimum of 3 apps, in order to also allow moving 1 and 2 apps a bit)
              //  + some constant value (still scales with the screen width) which looks good and somewhat fills the screen
              width: Math.max(3, ApplicationManager.count) * spreadView.tileDistance + (spreadView.width - spreadView.tileDistance) * 1.5
++            Behavior on width {
++                enabled: spreadView.closingIndex >= 0
++                UbuntuNumberAnimation {}
++            }
++            onWidthChanged: {
++                if (spreadView.closingIndex >= 0) {
++                    spreadView.contentX = Math.min(spreadView.contentX, width - spreadView.width - spreadView.shift);
++                }
++            }
              x: spreadView.contentX
@@ -462,18 +256,55 @@
                      height: spreadView.height
                      selected: spreadView.selectedIndex == index
                      otherSelected: spreadView.selectedIndex >= 0 && !selected
++                    interactive: !spreadView.interactive && spreadView.phase === 0
++                            && spreadView.shiftedContentX === 0 && root.interactive && index === 0
++                    swipeToCloseEnabled: spreadView.interactive
++                    maximizedAppTopMargin: root.maximizedAppTopMargin
++                    dropShadow: spreadView.shiftedContentX > 0 || spreadDragArea.status == DirectionalDragArea.Undecided
--                    z: index
++                    z: behavioredIndex
                      x: index == 0 ? 0 : spreadView.width + (index - 1) * spreadView.tileDistance
++                    property real behavioredIndex: index
++                    Behavior on behavioredIndex {
++                        enabled: spreadView.closingIndex >= 0
++                        UbuntuNumberAnimation {
++                            onRunningChanged: {
++                                if (!running) {
++                                    spreadView.closingIndex = -1;
++                                }
++                            }
++                        }
++                    }
++
++                    Behavior on x {
++                        enabled: spreadView.focusChanging && index == 0 && root.spreadEnabled
++                        UbuntuNumberAnimation {
++                            duration: UbuntuAnimation.FastDuration
++                            onRunningChanged: {
++                                if (!running) {
++                                    spreadView.focusChanging = false;
++                                }
++                            }
++                        }
++                    }
                      // Each tile has a different progress value running from 0 to 1.
--                    // A progress value of 0 means the tile is at the right edge. 1 means the tile has reched the left edge.
++                    // 0: means the tile is at the right edge.
++                    // 1: means the tile has finished the main animation towards the left edge.
++                    // >1: after the main animation has finished, tiles will continue to move very slowly to the left
                      progress: {
--                        var tileProgress = (spreadView.shiftedContentX - index * spreadView.tileDistance) / spreadView.width;
++                        var tileProgress = (spreadView.shiftedContentX - behavioredIndex * spreadView.tileDistance) / spreadView.width;
                          // Tile 1 needs to move directly from the beginning...
--                        if (index == 1 && spreadView.phase < 2) {
++                        if (behavioredIndex == 1 && spreadView.phase < 2) {
                              tileProgress += spreadView.tileDistance / spreadView.width;
+                         }
++                        // Limiting progress to ~0 and 1.7 to avoid binding calculations when tiles are not
++                        // visible.
++                        // < 0 :  The tile is outside the screen on the right
++                        // > 1.7: The tile is *very* close to the left edge and covered by other tiles now.
++                        // Using 0.0001 to differentiate when a tile should still be visible (==0)
++                        // or we can hide it (< 0)
++                        tileProgress = Math.max(-0.0001, Math.min(1.7, tileProgress));
                          return tileProgress;
+                     }
@@ -493,7 +324,7 @@
                      EasingCurve {
                          id: snappingCurve
--                        type: EasingCurve.OutQuad
++                        type: EasingCurve.Linear
                          period: 0.05
                          progress: appDelegate.progress - spreadView.positionMarker1
+                     }
@@ -507,7 +338,84 @@
+                             }
+                         }
+                     }
--                }
++
++                    onClosed: {
++                        spreadView.draggedIndex = -1;
++                        spreadView.closingIndex = index;
++                        ApplicationManager.stopApplication(ApplicationManager.get(index).appId);
++                    }
++                }
++            }
++        }
++    }
++
++    EdgeDragArea {
++        id: spreadDragArea
++        direction: Direction.Leftwards
++        enabled: spreadView.phase != 2 && root.spreadEnabled
++
++        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
++        width: root.dragAreaWidth
++
++        // Sitting at the right edge of the screen, this EdgeDragArea directly controls the spreadView when
++        // attachedToView is true. When the finger movement passes positionMarker3 we detach it from the
++        // spreadView and make the spreadView snap to positionMarker4.
++        property bool attachedToView: true
++
++        property var gesturePoints: new Array()
++
++        onTouchXChanged: {
++            if (!dragging) {
++                // Initial touch. Let's reset the spreadView to the starting position.
++                spreadView.phase = 0;
++                spreadView.contentX = -spreadView.shift;
++            }
++            if (dragging && attachedToView) {
++                // Gesture recognized. Let's move the spreadView with the finger
++                spreadView.contentX = -touchX + spreadDragArea.width - spreadView.shift;
++            }
++            if (attachedToView && spreadView.shiftedContentX >= spreadView.width * spreadView.positionMarker3) {
++                // We passed positionMarker3. Detach from spreadView and snap it.
++                attachedToView = false;
++                spreadView.snap();
++            }
++            gesturePoints.push(touchX);
++        }
++
++        onStatusChanged: {
++            if (status == DirectionalDragArea.Recognized) {
++                attachedToView = true;
++            }
++        }
++
++        onDraggingChanged: {
++            if (dragging) {
++                // Gesture recognized. Start recording this gesture
++                gesturePoints = [];
++                return;
++            }
++
++            // Ok. The user released. Find out if it was a one-way movement.
++            var oneWayFlick = true;
++            var smallestX = spreadDragArea.width;
++            for (var i = 0; i < gesturePoints.length; i++) {
++                if (gesturePoints[i] >= smallestX) {
++                    oneWayFlick = false;
++                    break;
++                }
++                smallestX = gesturePoints[i];
++            }
++            gesturePoints = [];
++
++            if (oneWayFlick && spreadView.shiftedContentX > units.gu(2) &&
++                    spreadView.shiftedContentX < spreadView.positionMarker1 * spreadView.width) {
++                // If it was a short one-way movement, do the Alt+Tab switch
++                // no matter if we didn't cross positionMarker1 yet.
++                spreadView.snapTo(1);
++            } else if (!dragging && attachedToView) {
++                // otherwise snap to the closest snap position we can find
++                // (might be back to start, to app 1 or to spread)
++                spreadView.snap();
+             }
+         }
+     }
 === removed file 'qml/Stages/SidestageHandle.qml'
 --- qml/Stages/SidestageHandle.qml	2014-03-04 11:49:28 +0000
 +++ qml/Stages/SidestageHandle.qml	1970-01-01 00:00:00 +0000
@@ -1,22 +0,0 @@
--/*
-- * Copyright (C) 2013 Canonical, Ltd.
-- *
-- * This program is free software; you can redistribute it and/or modify
-- * it under the terms of the GNU General Public License as published by
-- * the Free Software Foundation; version 3.
-- *
-- * This program is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- * GNU General Public License for more details.
-- *
-- * You should have received a copy of the GNU General Public License
-- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-- */
--
--import QtQuick 2.0
--import Ubuntu.Components 0.1
--
--BorderImage {
--    source: "graphics/sidestage_handle.sci"
--}
 === added file 'qml/Stages/Splash.qml'
 --- qml/Stages/Splash.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/Splash.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,68 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License 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.0
++import Ubuntu.Components 0.1
++import "../Components"
++
++Rectangle {
++    id: root
++    color: "black"
++
++    property string name: ""
++    property url image: ""
++
++    UbuntuShape {
++        id: iconShape
++        anchors.horizontalCenter: parent.horizontalCenter
++        anchors.verticalCenter: parent.verticalCenter
++        anchors.verticalCenterOffset: -units.gu(4)
++        width: units.gu(8)
++        height: units.gu(7.5)
++
++        radius: "medium"
++        borderSource: "none"
++
++        image: Image {
++            id: iconImage
++            sourceSize.width: iconShape.width
++            sourceSize.height: iconShape.height
++            source: root.image
++            fillMode: Image.PreserveAspectCrop
++        }
++    }
++
++    Label {
++        text: root.name
++        anchors.horizontalCenter: parent.horizontalCenter
++        anchors.top: iconShape.bottom
++        anchors.topMargin: units.gu(2)
++        fontSize: "large"
++    }
++
++    WaitingDots {
++        visible: parent.visible
++        anchors.horizontalCenter: parent.horizontalCenter
++        anchors.bottom: parent.bottom
++        anchors.bottomMargin: units.gu(12)
++    }
++
++    MouseArea {
++        anchors.fill: parent
++        enabled: parent.visible
++        // absorb all mouse events
++    }
++}
 === modified file 'qml/Stages/SpreadDelegate.qml'
 --- qml/Stages/SpreadDelegate.qml	2014-03-19 17:29:36 +0000
 +++ qml/Stages/SpreadDelegate.qml	2014-07-29 14:07:22 +0000
@@ -17,39 +17,203 @@
  */
  import QtQuick 2.0
++import Unity.Application 0.1
++import Ubuntu.Components 1.1
++import "../Components"
  Item {
      id: root
++    // to be set from outside
++    property bool interactive: true
++    property bool dropShadow: true
++    property real maximizedAppTopMargin
++    property alias swipeToCloseEnabled: dragArea.enabled
++
++    readonly property bool isFullscreen: surface !== null && surfaceContainer.surface.anchors.topMargin == 0
++
      signal clicked()
--
--    property real topMarginProgress
--
--    QtObject {
--        id: priv
--        property real heightDifference: root.height - appImage.implicitHeight
--    }
--
--    Image {
--        id: dropShadow
--        anchors.fill: appImage
--        anchors.margins: -units.gu(2)
--        source: "graphics/dropshadow.png"
--        opacity: .4
--    }
--    Image {
--        id: appImage
--        anchors {
--            left: parent.left;
--            bottom: parent.bottom;
--            top: parent.top;
--            topMargin: priv.heightDifference * Math.max(0, 1 - root.topMarginProgress)
--        }
--        source: model.screenshot
--        antialiasing: true
--    }
--    MouseArea {
--        anchors.fill: appImage
--        onClicked: root.clicked()
++    signal closed()
++
++    SurfaceContainer {
++        id: surfaceContainer
++        anchors.fill: parent
++        surface: model.surface
++        property bool appHasCreatedASurface: false
++
++        onSurfaceChanged: {
++            if (surface) {
++                if (!appHasCreatedASurface) {
++                    surface.visible = false; // hide until splash screen removed
++                    appHasCreatedASurface = true;
++                }
++            }
++        }
++
++        function revealSurface() {
++            surface.visible = true;
++            splashLoader.source = "";
++        }
++
++        Binding {
++            target: surfaceContainer.surface
++            property: "anchors.topMargin"
++            value: {
++                return surfaceContainer.surface.state === MirSurfaceItem.Fullscreen ? 0 : maximizedAppTopMargin;
++            }
++        }
++
++        Binding {
++            target: surface
++            property: "enabled"
++            value: root.interactive
++        }
++        Binding {
++            target: surface
++            property: "focus"
++            value: root.interactive
++        }
++
++        Timer { //FIXME - need to delay removing splash screen to allow surface resize to complete
++            id: surfaceRevealDelay
++            interval: 100
++            onTriggered: surfaceContainer.revealSurface()
++        }
++
++        Connections {
++            target: surface
++            // FIXME: I would rather not need to do this, but currently it doesn't get
++            // active focus without it and I don't know why.
++            onFocusChanged: forceSurfaceActiveFocusIfReady();
++            onParentChanged: forceSurfaceActiveFocusIfReady();
++            onEnabledChanged: forceSurfaceActiveFocusIfReady();
++            function forceSurfaceActiveFocusIfReady() {
++                if (surface.focus && surface.parent === surfaceContainer && surface.enabled) {
++                    surface.forceActiveFocus();
++                }
++            }
++        }
++
++        BorderImage {
++            id: dropShadowImage
++            anchors {
++                fill: parent
++                leftMargin: -units.gu(2)
++                rightMargin: -units.gu(2)
++                bottomMargin: -units.gu(2)
++                topMargin: -units.gu(2) + (root.isFullscreen ? 0 : maximizedAppTopMargin)
++            }
++            source: "graphics/dropshadow.png"
++            border { left: 50; right: 50; top: 50; bottom: 50 }
++            opacity: root.dropShadow ? .4 : 0
++            Behavior on opacity { UbuntuNumberAnimation {} }
++        }
++
++        transform: Translate {
++            y: dragArea.distance
++        }
++    }
++
++
++    StateGroup {
++        id: appSurfaceState
++        states: [
++            State {
++                name: "noSurfaceYet"
++                when: !surfaceContainer.appHasCreatedASurface
++                StateChangeScript {
++                    script: { splashLoader.setSource("Splash.qml", { "name": model.name, "image": model.icon }); }
++                }
++            },
++            State {
++                name: "hasSurface"
++                when: surfaceContainer.appHasCreatedASurface && (surfaceContainer.surface !== null)
++                StateChangeScript { script: { surfaceRevealDelay.start(); } }
++            },
++            State {
++                name: "surfaceLostButAppStillAlive"
++                when: surfaceContainer.appHasCreatedASurface && (surfaceContainer.surface === null)
++                // TODO - use app snapshot
++            }
++        ]
++        state: "noSurfaceYet"
++    }
++
++    Loader {
++        id: splashLoader
++        anchors.fill: surfaceContainer
++    }
++
++    DraggingArea {
++        id: dragArea
++        anchors.fill: parent
++
++        property bool moving: false
++        property real distance: 0
++
++        onMovingChanged: {
++            spreadView.draggedIndex = moving ? index : -1
++        }
++
++        onDragValueChanged: {
++            if (!dragging) {
++                return;
++            }
++            moving = moving || Math.abs(dragValue) > units.gu(1)
++            if (moving) {
++                distance = dragValue;
++            }
++        }
++
++        onClicked: {
++            if (!moving) {
++                root.clicked();
++            }
++        }
++
++        onDragEnd: {
++            // velocity and distance values specified by design prototype
++            if ((dragVelocity < -units.gu(40) && distance < -units.gu(8)) || distance < -root.height / 2) {
++                animation.animate("up")
++            } else if ((dragVelocity > units.gu(40) && distance > units.gu(8)) || distance > root.height / 2) {
++                animation.animate("down")
++            } else {
++                animation.animate("center")
++            }
++        }
++
++        UbuntuNumberAnimation {
++            id: animation
++            target: dragArea
++            property: "distance"
++            property bool requestClose: false
++
++            function animate(direction) {
++                animation.from = dragArea.distance;
++                switch (direction) {
++                case "up":
++                    animation.to = -root.height * 1.5;
++                    requestClose = true;
++                    break;
++                case "down":
++                    animation.to = root.height * 1.5;
++                    requestClose = true;
++                    break;
++                default:
++                    animation.to = 0
++                }
++                animation.start();
++            }
++
++            onRunningChanged: {
++                if (!running) {
++                    dragArea.moving = false;
++                    dragArea.distance = 0;
++                    if (requestClose) {
++                        root.closed();
++                    }
++                }
++            }
++        }
+     }
+ }
 === removed file 'qml/Stages/StageWithSideStage.qml'
 --- qml/Stages/StageWithSideStage.qml	2014-05-26 14:12:20 +0000
 +++ qml/Stages/StageWithSideStage.qml	1970-01-01 00:00:00 +0000
@@ -1,413 +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.0
--import Ubuntu.Components 0.1
--import "../Components"
--import Unity.Application 0.1
--import Ubuntu.Gestures 0.1
--
--Item {
--    id: root
--    objectName: "stages"
--    anchors.fill: parent
--
--    // Controls to be set from outside
--    property bool shown: false
--    property bool moving: false
--    property int dragAreaWidth
--
--    // State information propagated to the outside
--    readonly property bool painting: mainStageImage.visible || sideStageImage.visible || sideStageSnapAnimation.running
--    property bool fullscreen: priv.focusedApplication ? priv.focusedApplication.fullscreen : false
--    property bool overlayMode: (sideStageImage.shown && priv.mainStageAppId.length == 0) || priv.overlayOverride
--                               || (priv.mainStageAppId.length == 0 && sideStageSnapAnimation.running)
--
--    readonly property int overlayWidth: priv.overlayOverride ? 0 : priv.sideStageWidth
--
--    onShownChanged: {
--        if (!shown) {
--            priv.mainStageAppId = "";
--        }
--    }
--
--    onMovingChanged: {
--        if (moving) {
--            if (!priv.mainStageAppId && !priv.sideStageAppId) {
--                // Pulling in from the right, make the last used (topmost) app visible
--                var application = ApplicationManager.get(0);
--                if (application.stage == ApplicationInfoInterface.SideStage) {
--                    sideStageImage.application = application;
--                    sideStageImage.x = root.width - sideStageImage.width
--                    sideStageImage.visible = true;
--                } else {
--                    mainStageImage.application = application;
--                    mainStageImage.visible = true;
--                }
--            } else {
--                priv.requestNewScreenshot(ApplicationInfoInterface.MainStage)
--                if (priv.focusedApplicationId == priv.sideStageAppId) {
--                    priv.requestNewScreenshot(ApplicationInfoInterface.SideStage)
--                }
--            }
--        } else {
--            mainStageImage.visible = false;
--            sideStageImage.visible = false;
--        }
--    }
--
--    QtObject {
--        id: priv
--
--        property int sideStageWidth: units.gu(40)
--
--
--        property string sideStageAppId
--        property string mainStageAppId
--
--
--        property var sideStageApp: ApplicationManager.findApplication(sideStageAppId)
--        property var mainStageApp: ApplicationManager.findApplication(mainStageAppId)
--
--        property string sideStageScreenshot: sideStageApp ? sideStageApp.screenshot : ""
--        property string mainStageScreenshot: mainStageApp ? mainStageApp.screenshot : ""
--
--        property string focusedApplicationId: ApplicationManager.focusedApplicationId
--        property var focusedApplication: ApplicationManager.findApplication(focusedApplicationId)
--        property url focusedScreenshot: focusedApplication ? focusedApplication.screenshot : ""
--
--        property bool waitingForMainScreenshot: false
--        property bool waitingForSideScreenshot: false
--        property bool waitingForScreenshots: waitingForMainScreenshot || waitingForSideScreenshot
--
--        property string startingAppId: ""
--
--        // Keep overlayMode even if there is no focused app (to allow pulling in the sidestage from the right)
--        property bool overlayOverride: false
--
--        onFocusedApplicationChanged: {
--            if (focusedApplication) {
--                if (focusedApplication.stage == ApplicationInfoInterface.MainStage) {
--                    mainStageAppId = focusedApplicationId;
--                    priv.overlayOverride = false;
--                    if (priv.startingAppId == focusedApplicationId && sideStageImage.shown) {
--                        // There was already a sidestage app on top. bring it back!
--                        ApplicationManager.focusApplication(priv.sideStageAppId)
--                        priv.startingAppId = "";
--                    }
--                } else if (focusedApplication.stage == ApplicationInfoInterface.SideStage) {
--                    sideStageAppId = focusedApplicationId;
--                    if (priv.startingAppId == focusedApplicationId && !sideStageImage.shown) {
--                        sideStageImage.snapToApp(focusedApplication);
--                        priv.startingAppId = "";
--                    }
--                }
--            } else if (root.overlayMode){
--                sideStageImage.snapTo(root.width)
--            }
--        }
--
--        onMainStageScreenshotChanged: {
--            waitingForMainScreenshot = false;
--        }
--
--        onSideStageScreenshotChanged: {
--            waitingForSideScreenshot = false;
--        }
--
--        onFocusedScreenshotChanged: {
--            waitingForSideScreenshot = false;
--        }
--
--        onWaitingForScreenshotsChanged: {
--            if (waitingForScreenshots) {
--                return;
--            }
--
--            if (root.moving) {
--                if (mainStageAppId) {
--                    mainStageImage.application = mainStageApp
--                    mainStageImage.visible = true;
--                }
--                if (sideStageAppId && focusedApplicationId == sideStageAppId) {
--                    sideStageImage.application = sideStageApp;
--                    sideStageImage.x = root.width - sideStageImage.width
--                    sideStageImage.visible = true;
--                }
--            }
--            if (sideStageHandleMouseArea.pressed) {
--                if (sideStageAppId) {
--                    sideStageImage.application = sideStageApp;
--                    sideStageImage.x = root.width - sideStageImage.width
--                    sideStageImage.visible = true;
--                }
--                if (mainStageAppId) {
--                    mainStageImage.application = mainStageApp
--                    mainStageImage.visible = true;
--                }
--            }
--        }
--
--        function requestNewScreenshot(stage) {
--            if (stage == ApplicationInfoInterface.MainStage && mainStageAppId) {
--                waitingForMainScreenshot = true;
--                ApplicationManager.updateScreenshot(mainStageAppId);
--            } else if (stage == ApplicationInfoInterface.SideStage && sideStageAppId) {
--                waitingForSideScreenshot = true;
--                ApplicationManager.updateScreenshot(sideStageAppId);
--            }
--        }
--
--    }
--    // FIXME: the signal connection seems to get lost with the fake application manager.
--    Connections {
--        target: priv.sideStageApp
--        onScreenshotChanged: priv.sideStageScreenshot = priv.sideStageApp.screenshot
--    }
--    Connections {
--        target: priv.mainStageApp
--        onScreenshotChanged: priv.mainStageScreenshot = priv.mainStageApp.screenshot
--    }
--
--    Connections {
--        target: ApplicationManager
--
--        onApplicationAdded: {
--            priv.startingAppId = appId;
--            splashScreenTimer.start();
--            var application = ApplicationManager.findApplication(appId)
--            if (application.stage == ApplicationInfoInterface.SideStage) {
--                sideStageSplash.visible = true;
--            } else if (application.stage == ApplicationInfoInterface.MainStage) {
--                mainStageSplash.visible = true;
--            }
--        }
--
--        onFocusRequested: {
--            var application = ApplicationManager.findApplication(appId)
--            if (application.stage == ApplicationInfoInterface.SideStage) {
--                if (!root.shown) {
--                    priv.mainStageAppId = "";
--                    mainStageImage.application = null
--                }
--                if (sideStageImage.shown) {
--                    sideStageImage.switchTo(application);
--                    if (priv.mainStageAppId) {
--                        mainStageImage.application = priv.mainStageApp;
--                        mainStageImage.visible = true;
--                    }
--                } else {
--                    sideStageImage.application = application;
--                    sideStageImage.snapToApp(application);
--                }
--            } else if (application.stage == ApplicationInfoInterface.MainStage) {
--                if (root.shown) {
--                    if (sideStageImage.shown) {
--                        sideStageImage.application = priv.sideStageApp;
--                        sideStageImage.visible = true;
--                    }
--                    priv.mainStageAppId = application.appId;
--                    mainStageImage.switchTo(application)
--                    ApplicationManager.focusApplication(appId)
--                    if (sideStageImage.shown) {
--                        // There was already a focused SS app. Bring it back
--                        ApplicationManager.focusApplication(priv.sideStageAppId)
--                    }
--                } else {
--                    if (sideStageImage.shown) {
--                        sideStageImage.visible = false;
--                        sideStageImage.x = root.width;
--                    }
--
--                    mainStageImage.application = application;
--                    ApplicationManager.focusApplication(appId)
--                }
--            }
--        }
--
--        onApplicationRemoved: {
--            if (priv.mainStageAppId == appId) {
--                priv.mainStageAppId = "";
--            }
--            if (priv.sideStageAppId == appId) {
--                priv.sideStageAppId = "";
--            }
--            if (priv.sideStageAppId.length == 0) {
--                sideStageImage.shown = false;
--                priv.overlayOverride = false;
--            }
--        }
--
--    }
--
--    Timer {
--        id: splashScreenTimer
--        // FIXME: apart from removing this completely in the future and make the app surface paint
--        // meaningful stuff, also check for colin's stuff to land so we can shape 1.4 secs away from here
--        // https://code.launchpad.net/~cjwatson/upstart-app-launch/libclick-manifest/+merge/210520
--        // https://code.launchpad.net/~cjwatson/upstart-app-launch/libclick-pkgdir/+merge/209909
--        interval: 1700
--        repeat: false
--        onTriggered: {
--            mainStageSplash.visible = false;
--            sideStageSplash.visible = false;
--        }
--    }
--
--    SwitchingApplicationImage {
--        id: mainStageImage
--        anchors.bottom: parent.bottom
--        width: parent.width
--        visible: false
--
--        onSwitched: {
--            sideStageImage.visible = false;
--        }
--    }
--
--    Rectangle {
--        id: mainStageSplash
--        anchors.fill: root
--        anchors.rightMargin: root.width - sideStageImage.x
--        color: "black"
--
--        WaitingDots {
--        }
--    }
--
--    SidestageHandle {
--        id: sideStageHandle
--        anchors { top: parent.top; right: sideStageImage.left; bottom: parent.bottom }
--        width: root.dragAreaWidth
--        visible: root.shown && priv.sideStageAppId && sideStageImage.x < root.width
--
--    }
--    MouseArea {
--        id: sideStageHandleMouseArea
--        anchors { top: parent.top; right: parent.right; bottom: parent.bottom; rightMargin: sideStageImage.shown ? sideStageImage.width : 0}
--        width: root.dragAreaWidth
--        visible: priv.sideStageAppId
--
--        property var dragPoints: new Array()
--
--        onPressed: {
--            priv.requestNewScreenshot(ApplicationInfoInterface.SideStage)
--            if (priv.mainStageAppId) {
--                priv.requestNewScreenshot(ApplicationInfoInterface.MainStage)
--            }
--        }
--
--        onMouseXChanged: {
--            dragPoints.push(mouseX)
--
--            var dragPoint = root.width + mouseX;
--            if (sideStageImage.shown) {
--                dragPoint -= sideStageImage.width
--            }
--            sideStageImage.x = Math.max(root.width - sideStageImage.width, dragPoint)
--        }
--
--        onReleased: {
--            var distance = 0;
--            var lastX = dragPoints[0];
--            var oneWayFlick = true;
--            for (var i = 0; i < dragPoints.length; ++i) {
--                if (dragPoints[i] < lastX) {
--                    oneWayFlick = false;
--                }
--                distance += dragPoints[i] - lastX;
--                lastX = dragPoints[i];
--            }
--            dragPoints = [];
--
--            if (oneWayFlick || distance > sideStageImage.width / 2) {
--                sideStageImage.snapTo(root.width)
--            } else {
--                sideStageImage.snapToApp(priv.sideStageApp)
--            }
--        }
--    }
--
--    SwitchingApplicationImage {
--        id: sideStageImage
--        width: priv.sideStageWidth
--        height: root.height
--        x: root.width
--        anchors.bottom: parent.bottom
--        visible: true
--        property bool shown: false
--
--        onSwitched: {
--            mainStageImage.visible = false;
--            ApplicationManager.focusApplication(application.appId)
--        }
--
--        function snapTo(targetX) {
--            sideStageSnapAnimation.targetX = targetX
--            sideStageImage.visible = true;
--            if (priv.mainStageAppId) {
--                mainStageImage.application = priv.mainStageApp
--                mainStageImage.visible = true;
--            }
--            sideStageSnapAnimation.start();
--        }
--
--        function snapToApp(application) {
--            sideStageImage.application = application
--            sideStageSnapAnimation.snapToId = application.appId;
--            snapTo(root.width - sideStageImage.width);
--        }
--
--        SequentialAnimation {
--            id: sideStageSnapAnimation
--            property int targetX: root.width
--            property string snapToId
--
--            UbuntuNumberAnimation { target: sideStageImage; property: "x"; to: sideStageSnapAnimation.targetX; duration: UbuntuAnimation.SlowDuration }
--            ScriptAction {
--                script: {
--                    if (sideStageSnapAnimation.targetX == root.width) {
--                        if (priv.mainStageAppId) {
--                            ApplicationManager.focusApplication(priv.mainStageAppId)
--                        } else {
--                            priv.overlayOverride = true;
--                            ApplicationManager.unfocusCurrentApplication();
--                        }
--                        sideStageImage.shown = false;
--                    }
--                    if (sideStageSnapAnimation.snapToId) {
--                        ApplicationManager.focusApplication(sideStageSnapAnimation.snapToId)
--                        sideStageSnapAnimation.snapToId = "";
--                        sideStageImage.shown = true;
--                        priv.overlayOverride = false;
--                    }
--                    sideStageImage.visible = false;
--                    mainStageImage.visible = false;
--                }
--            }
--        }
--    }
--
--    Rectangle {
--        id: sideStageSplash
--        anchors.fill: parent
--        anchors.leftMargin: sideStageImage.x
--        color: "black"
--
--        WaitingDots {
--        }
--    }
--}
 === added file 'qml/Stages/SurfaceContainer.qml'
 --- qml/Stages/SurfaceContainer.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/SurfaceContainer.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,123 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License 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.0
++import "Animations"
++
++Item {
++    id: container
++    property Item surface: null
++    property bool removing: false
++
++    onSurfaceChanged: {
++        if (surface) {
++            surface.parent = container;
++            surface.z = 1;
++            state = "initial"
++        }
++    }
++
++    Connections {
++        target: surface
++        onRemoved: {
++            container.removing = true;
++
++            var childSurfaces = surface.childSurfaces;
++            for (var i=0; i<childSurfaces.length; i++) {
++                childSurfaces[i].removed();
++            }
++
++            //if we don't have children, nothing will tell us to animate out, so do it.
++            if (childSurfaces.length === 0) {
++                animateOut();
++            }
++            // tell our parent to animate out.
++            if (surface.parentSurface) {
++                surface.parentSurface.parent.animateOut();
++            }
++        }
++    }
++
++    Repeater {
++        model: container.surface ? container.surface.childSurfaces : 0
++
++        delegate: Loader {
++            z: 2
++            anchors {
++                fill: container
++                topMargin: container.surface.anchors.topMargin
++                rightMargin: container.surface.anchors.rightMargin
++                bottomMargin: container.surface.anchors.bottomMargin
++                leftMargin: container.surface.anchors.leftMargin
++            }
++
++            // Only way to do recursive qml items.
++            source: Qt.resolvedUrl("SurfaceContainer.qml")
++            onLoaded: {
++                item.surface = modelData;
++                item.animateIn(swipeFromBottom);
++                container.animateIn(swipeUp);
++            }
++        }
++    }
++
++    function animateIn(component) {
++        var animation = component.createObject(container, { "surface": container.surface });
++        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.end();
++            d.animations = tmp;
++        } else {
++            container.state = "initial";
++        }
++    }
++
++    QtObject {
++        id: d
++        property var animations: []
++        property var currentAnimation: animations.length > 0 ? animations[animations.length-1] : undefined
++    }
++
++    Component {
++        id: swipeFromBottom
++        SwipeFromBottomAnimation {}
++    }
++    Component {
++        id: swipeUp
++        SwipeUpAnimation {}
++    }
++    Component {
++        id: darkenFade
++        DarkenAndFadeInAnimation {}
++    }
++
++    states: [
++        State {
++            name: "initial"
++            PropertyChanges { target: surface; anchors.fill: container }
++        }
++        // TODO: more animations!
++    ]
++}
 === removed file 'qml/Stages/SwitchingApplicationImage.qml'
 --- qml/Stages/SwitchingApplicationImage.qml	2014-03-19 18:09:27 +0000
 +++ qml/Stages/SwitchingApplicationImage.qml	1970-01-01 00:00:00 +0000
@@ -1,81 +0,0 @@
--/*
-- * Copyright 2014 Canonical Ltd.
-- *
-- * This program is free software; you can redistribute it and/or modify
-- * it under the terms of the GNU Lesser General Public License 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/>.
-- *
-- * Authors: Michael Zanetti <michael.zanetti@canonical.com>
--*/
--
--import QtQuick 2.0
--import Ubuntu.Components 0.1
--
--Rectangle {
--    id: root
--    implicitHeight: image.implicitHeight
--    implicitWidth: image.implicitWidth
--    color: "black"
--
--    property var application
--
--    signal switched()
--
--    function switchTo(application) {
--        if (root.application == application) {
--            root.switched();
--            return;
--        }
--
--        priv.newApplication = application
--        root.visible = true;
--        switchToAnimation.start()
--    }
--
--    QtObject {
--        id: priv
--        property var newApplication
--    }
--
--    Image {
--        id: newImage
--        anchors.bottom: parent.bottom
--        width: root.width
--        source: priv.newApplication ? priv.newApplication.screenshot : ""
--    }
--
--    Image {
--        id: image
--        visible: true
--        source: root.application ? root.application.screenshot : ""
--        width: root.width
--        height: sourceSize.height
--        anchors.bottom: parent.bottom
--
--    }
--
--    SequentialAnimation {
--        id: switchToAnimation
--        ParallelAnimation {
--            UbuntuNumberAnimation { target: image; property: "x"; from: 0; to: root.width; duration: UbuntuAnimation.SlowDuration }
--            UbuntuNumberAnimation { target: newImage; property: "scale"; from: 0.7; to: 1; duration: UbuntuAnimation.SlowDuration }
--        }
--        ScriptAction {
--            script: {
--                image.x = 0
--                root.application = priv.newApplication
--                root.visible = false;
--                priv.newApplication = null
--                root.switched();
--            }
--        }
--    }
--}
 === added file 'qml/Stages/TabletStage.qml'
 --- qml/Stages/TabletStage.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/TabletStage.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,568 @@
++/*
++ * 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.0
++import Ubuntu.Components 0.1
++import Ubuntu.Gestures 0.1
++import Unity.Application 0.1
++import Utils 0.1
++import "../Components"
++
++Item {
++    id: root
++    objectName: "stages"
++    anchors.fill: parent
++
++    // Controls to be set from outside
++    property bool shown: false
++    property bool moving: false
++    property int dragAreaWidth
++    property real maximizedAppTopMargin
++    property bool interactive
++
++    // State information propagated to the outside
++    readonly property bool locked: spreadView.phase == 2
++
++    QtObject {
++        id: priv
++
++        property string focusedAppId: ApplicationManager.focusedApplicationId
++        property string oldFocusedAppId: ""
++
++        property string mainStageAppId
++        property string sideStageAppId
++
++        // For convenience, keep properties of the first two apps in the model
++        property string appId0
++        property string appId1
++
++        onFocusedAppIdChanged: {
++            if (priv.focusedAppId.length > 0) {
++                var focusedApp = ApplicationManager.findApplication(focusedAppId);
++                if (focusedApp.stage == ApplicationInfoInterface.SideStage) {
++                    priv.sideStageAppId = focusedAppId;
++                } else {
++                    priv.mainStageAppId = focusedAppId;
++                }
++            }
++
++            appId0 = ApplicationManager.count >= 1 ? ApplicationManager.get(0).appId : "";
++            appId1 = ApplicationManager.count > 1 ? ApplicationManager.get(1).appId : "";
++        }
++
++        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) {
++                return false;
++            }
++            // Need to have a movement of at least 2 grid units to recognize it as a flick
++            if (Math.abs(gesturePoints[gesturePoints.length - 1] - gesturePoints[0]) < units.gu(2)) {
++                return false;
++            }
++
++            var oneWayFlick = true;
++            var smallestX = gesturePoints[0];
++            var leftWards = gesturePoints[1] < gesturePoints[0];
++            for (var i = 1; i < gesturePoints.length; i++) {
++                if ((leftWards && gesturePoints[i] >= smallestX)
++                        || (!leftWards && gesturePoints[i] <= smallestX)) {
++                    oneWayFlick = false;
++                    break;
++                }
++                smallestX = gesturePoints[i];
++            }
++            return oneWayFlick;
++        }
++    }
++
++    Connections {
++        target: ApplicationManager
++        onFocusRequested: {
++            if (spreadView.interactive) {
++                spreadView.snapTo(priv.indexOf(appId));
++            } else {
++                ApplicationManager.focusApplication(appId);
++            }
++        }
++
++        onApplicationRemoved: {
++            if (priv.mainStageAppId == appId) {
++                priv.mainStageAppId = "";
++            }
++            if (priv.sideStageAppId == appId) {
++                priv.sideStageAppId = "";
++            }
++            if (ApplicationManager.count == 0) {
++                spreadView.phase = 0;
++                spreadView.contentX = 0;
++            }
++        }
++    }
++
++    Flickable {
++        id: spreadView
++        anchors.fill: parent
++        contentWidth: spreadRow.width
++        interactive: (spreadDragArea.status == DirectionalDragArea.Recognized || phase > 1) && draggedIndex == -1
++
++        property int tileDistance: units.gu(20)
++        property int sideStageWidth: units.gu(40)
++        property bool sideStageVisible: priv.sideStageAppId
++
++        // Phase of the animation:
++        // 0: Starting from right edge, a new app (index 1) comes in from the right
++        // 1: The app has reached the first snap position.
++        // 2: The list is dragged further and snaps into the spread view when entering phase 2
++        property int phase
++
++        readonly property int phase0Width: sideStageWidth
++        readonly property int phase1Width: sideStageWidth
++
++        // Those markers mark the various positions in the spread (ratio to screen width from right to left):
++        // 0 - 1: following finger, snap back to the beginning on release
++        readonly property real positionMarker1: 0.2
++        // 1 - 2: curved snapping movement, snap to nextInStack on release
++        readonly property real positionMarker2: sideStageWidth / spreadView.width
++        // 2 - 3: movement follows finger, snaps to phase 2 (full spread) on release
++        readonly property real positionMarker3: 0.6
++        // passing 3, we detach movement from the finger and snap to phase 2 (full spread)
++        readonly property real positionMarker4: 0.8
++
++        readonly property int startSnapPosition: phase0Width * 0.5
++        readonly property int endSnapPosition: phase0Width * 0.75
++        readonly property real snapPosition: 0.75
++
++        property int selectedIndex: -1
++        property int draggedIndex: -1
++        property int closingIndex: -1
++
++        property bool sideStageDragging: sideStageDragHandle.dragging
++        property real sideStageDragProgress: sideStageDragHandle.progress
++
++        onSideStageDragProgressChanged: {
++            if (sideStageDragProgress == 1) {
++                ApplicationManager.focusApplication(priv.mainStageAppId);
++                priv.sideStageAppId = "";
++            }
++        }
++
++        property int nextInStack: {
++            switch (state) {
++            case "main":
++                if (ApplicationManager.count > 1) {
++                    return 1;
++                }
++                return -1;
++            case "mainAndOverlay":
++                if (ApplicationManager.count <= 2) {
++                    return -1;
++                }
++                if (priv.appId0 == priv.mainStageAppId || priv.appId0 == priv.sideStageAppId) {
++                    if (priv.appId1 == priv.mainStageAppId || priv.appId1 == priv.sideStageAppId) {
++                        return 2;
++                    }
++                    return 1;
++                }
++                return 0;
++            case "overlay":
++                return 1;
++            }
++            print("Unhandled nextInStack case! This shouldn't happen any more when the Dash is an app!");
++            return -1;
++        }
++        property int nextZInStack: indexToZIndex(nextInStack)
++
++        states: [
++            State {
++                name: "empty"
++            },
++            State {
++                name: "main"
++            },
++            State { // Side Stage only in overlay mode
++                name: "overlay"
++            },
++            State { // Main Stage and Side Stage in overlay mode
++                name: "mainAndOverlay"
++            },
++            State { // Main Stage and Side Stage in split mode
++                name: "mainAndSplit"
++            }
++        ]
++        state: {
++            if (priv.mainStageAppId && !priv.sideStageAppId) {
++                return "main";
++            }
++            if (!priv.mainStageAppId && priv.sideStageAppId) {
++                return "overlay";
++            }
++            if (priv.mainStageAppId && priv.sideStageAppId) {
++                return "mainAndOverlay";
++            }
++            return "empty";
++        }
++
++        onContentXChanged: {
++            if (spreadView.phase == 0 && spreadView.contentX > spreadView.width * spreadView.positionMarker2) {
++                spreadView.phase = 1;
++            } else if (spreadView.phase == 1 && spreadView.contentX > spreadView.width * spreadView.positionMarker4) {
++                spreadView.phase = 2;
++            } else if (spreadView.phase == 1 && spreadView.contentX < spreadView.width * spreadView.positionMarker2) {
++                spreadView.phase = 0;
++            }
++        }
++
++        function snap() {
++            if (contentX < phase0Width) {
++                snapAnimation.targetContentX = 0;
++                snapAnimation.start();
++            } else if (contentX < phase1Width) {
++                snapTo(1);
++            } else {
++                // Add 1 pixel to make sure we definitely hit positionMarker4 even with rounding errors of the animation.
++                snapAnimation.targetContentX = spreadView.width * spreadView.positionMarker4 + 1;
++                snapAnimation.start();
++            }
++        }
++        function snapTo(index) {
++            spreadView.selectedIndex = index;
++            snapAnimation.targetContentX = 0;
++            snapAnimation.start();
++        }
++
++        // We need to shuffle z ordering a bit in order to keep side stage apps above main stage apps.
++        // We don't want to really reorder them in the model because that allows us to keep track
++        // of the last focused order.
++        function indexToZIndex(index) {
++            var app = ApplicationManager.get(index);
++            if (!app) {
++                return index;
++            }
++
++            var isActive = app.appId == priv.mainStageAppId || app.appId == priv.sideStageAppId;
++            if (isActive && app.stage == ApplicationInfoInterface.MainStage) {
++                // if this app is active, and its the MainStage, always put it to index 0
++                return 0;
++            }
++            if (isActive && app.stage == ApplicationInfoInterface.SideStage) {
++                if (!priv.mainStageAppId) {
++                    // Only have SS apps running. Put the active one at 0
++                    return 0;
++                }
++
++                // Precondition now: There's an active MS app and this is SS app:
++                if (spreadView.nextInStack >= 0 && ApplicationManager.get(spreadView.nextInStack).stage == ApplicationInfoInterface.MainStage) {
++                    // If the next app coming from the right is a MS app, we need to elevate this SS ap above it.
++                    // Put it to at least level 2, or higher if there's more apps coming in before this one.
++                    return Math.max(index, 2);
++                } else {
++                    // if this is no next app to come in from the right, place this one at index 1, just on top the active MS app.
++                    return 1;
++                }
++            }
++            if (index <= 2 && app.stage == ApplicationInfoInterface.MainStage && priv.sideStageAppId) {
++                // Ok, this is an inactive MS app. If there's an active SS app around, we need to place this one
++                // in between the active MS app and the active SS app, so that it comes in from there when dragging from the right.
++                // If there's now active SS app, just leave it where it is.
++                return priv.indexOf(priv.sideStageAppId) < index ? index - 1 : index;
++            }
++            if (index == spreadView.nextInStack && app.stage == ApplicationInfoInterface.SideStage) {
++                // This is a SS app and the next one to come in from the right:
++                if (priv.sideStageAppId && priv.mainStageAppId) {
++                    // If there's both, an active MS and an active SS app, put this one right on top of that
++                    return 2;
++                }
++                // Or if there's only one other active app, put it on top of that.
++                // The case that there isn't any other active app is already handled above.
++                return 1;
++            }
++            if (index == 2 && spreadView.nextInStack == 1 && priv.sideStageAppId) {
++                // If its index 2 but not the next one to come in, it means
++                // we've pulled another one down to index 2. Move this one up to 2 instead.
++                return 3;
++            }
++            // don't touch all others... (mostly index > 3 + simple cases where the above doesn't shuffle much)
++            return index;
++        }
++
++        SequentialAnimation {
++            id: snapAnimation
++            property int targetContentX: 0
++
++            UbuntuNumberAnimation {
++                target: spreadView
++                property: "contentX"
++                to: snapAnimation.targetContentX
++                duration: UbuntuAnimation.FastDuration
++            }
++
++            ScriptAction {
++                script: {
++                    if (spreadView.selectedIndex >= 0) {
++                        var newIndex = spreadView.selectedIndex;
++                        spreadView.selectedIndex = -1;
++                        ApplicationManager.focusApplication(ApplicationManager.get(newIndex).appId);
++                        spreadView.phase = 0;
++                        spreadView.contentX = 0;
++                    }
++                }
++            }
++        }
++
++        Rectangle {
++            id: spreadRow
++            color: "black"
++            x: spreadView.contentX
++            height: root.height
++            width: spreadView.width + Math.max(spreadView.width, ApplicationManager.count * spreadView.tileDistance)
++
++            Rectangle {
++                id: sideStageBackground
++                color: "black"
++                anchors.fill: parent
++                anchors.leftMargin: spreadView.width - (1 - sideStageDragHandle.progress) * spreadView.sideStageWidth
++                z: spreadView.indexToZIndex(priv.indexOf(priv.sideStageAppId))
++                opacity: spreadView.phase == 0 ? 1 : 0
++                Behavior on opacity { UbuntuNumberAnimation {} }
++            }
++
++            Item {
++                id: sideStageDragHandle
++                anchors { top: parent.top; bottom: parent.bottom; left: parent.left; leftMargin: spreadView.width - spreadView.sideStageWidth - width }
++                width: units.gu(2)
++                z: sideStageBackground.z
++                opacity: spreadView.phase <= 0 && spreadView.sideStageVisible ? 1 : 0
++                property real progress: 0
++                property bool dragging: false
++
++                Behavior on opacity { UbuntuNumberAnimation {} }
++
++                Connections {
++                    target: spreadView
++                    onSideStageVisibleChanged: {
++                        if (spreadView.sideStageVisible) {
++                            sideStageDragHandle.progress = 0;
++                        }
++                    }
++                }
++
++                Image {
++                    anchors.centerIn: parent
++                    anchors.horizontalCenterOffset: parent.progress * spreadView.sideStageWidth - (width - parent.width) / 2
++                    width: sideStageDragHandleMouseArea.pressed ? parent.width * 2 : parent.width
++                    height: parent.height
++                    source: "graphics/sidestage_handle@20.png"
++                    Behavior on width { UbuntuNumberAnimation {} }
++                }
++
++                MouseArea {
++                    id: sideStageDragHandleMouseArea
++                    anchors.fill: parent
++                    enabled: spreadView.contentX == 0
++                    property int startX
++                    property var gesturePoints: new Array()
++
++                    onPressed: {
++                        gesturePoints = [];
++                        startX = mouseX;
++                        sideStageDragHandle.progress = 0;
++                        sideStageDragHandle.dragging = true;
++                    }
++                    onMouseXChanged: {
++                        if (priv.mainStageAppId) {
++                            sideStageDragHandle.progress = Math.max(0, (-startX + mouseX) / spreadView.sideStageWidth);
++                        }
++                        gesturePoints.push(mouseX);
++                    }
++                    onReleased: {
++                        if (priv.mainStageAppId) {
++                            var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
++                            sideStageDragSnapAnimation.to = sideStageDragHandle.progress > 0.5 || oneWayFlick ? 1 : 0;
++                            sideStageDragSnapAnimation.start();
++                        } else {
++                            sideStageDragHandle.dragging = false;
++                        }
++                    }
++                }
++                UbuntuNumberAnimation {
++                    id: sideStageDragSnapAnimation
++                    target: sideStageDragHandle
++                    property: "progress"
++
++                    onRunningChanged: {
++                        if (!running) {
++                            sideStageDragHandle.dragging = false;;
++                        }
++                    }
++                }
++            }
++
++            Repeater {
++                id: spreadRepeater
++                model: ApplicationManager
++
++                delegate: TransformedTabletSpreadDelegate {
++                    id: spreadTile
++                    height: spreadView.height
++                    width: model.stage == ApplicationInfoInterface.MainStage ? spreadView.width : spreadView.sideStageWidth
++                    x: spreadView.width
++                    z: spreadView.indexToZIndex(index)
++                    active: model.appId == priv.mainStageAppId || model.appId == priv.sideStageAppId
++                    zIndex: z
++                    selected: spreadView.selectedIndex == index
++                    otherSelected: spreadView.selectedIndex >= 0 && !selected
++                    isInSideStage: priv.sideStageAppId == model.appId
++                    interactive: !spreadView.interactive && spreadView.phase === 0 && root.interactive
++                    swipeToCloseEnabled: spreadView.interactive
++                    maximizedAppTopMargin: root.maximizedAppTopMargin
++                    dropShadow: spreadView.contentX > 0 || spreadDragArea.status == DirectionalDragArea.Undecided
++
++                    property real behavioredZIndex: zIndex
++                    Behavior on behavioredZIndex {
++                        enabled: spreadView.closingIndex >= 0
++                        UbuntuNumberAnimation {}
++                    }
++
++                    // 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);
++                        })
++                    }
++
++                    progress: {
++                        var tileProgress = (spreadView.contentX - behavioredZIndex * spreadView.tileDistance) / spreadView.width;
++                        // Some tiles (nextInStack, active) need to move directly from the beginning, normalize progress to immediately start at 0
++                        if ((index == spreadView.nextInStack && spreadView.phase < 2) || (active && spreadView.phase < 1)) {
++                            tileProgress += behavioredZIndex * spreadView.tileDistance / spreadView.width;
++                        }
++                        return tileProgress;
++                    }
++
++                    animatedProgress: {
++                        if (spreadView.phase == 0 && (spreadTile.active || spreadView.nextInStack == index)) {
++                            if (progress < spreadView.positionMarker1) {
++                                return progress;
++                            } else if (progress < spreadView.positionMarker1 + snappingCurve.period) {
++                                return spreadView.positionMarker1 + snappingCurve.value * 3;
++                            } else {
++                                return spreadView.positionMarker2;
++                            }
++                        }
++                        return progress;
++                    }
++
++                    onClicked: {
++                        if (spreadView.phase == 2) {
++                            if (ApplicationManager.focusedApplicationId == ApplicationManager.get(index).appId) {
++                                spreadView.snapTo(index);
++                            } else {
++                                ApplicationManager.requestFocusApplication(ApplicationManager.get(index).appId);
++                            }
++                        }
++                    }
++
++                    onClosed: {
++                        spreadView.draggedIndex = -1;
++                        spreadView.closingIndex = index;
++                        ApplicationManager.stopApplication(ApplicationManager.get(index).appId);
++                    }
++
++                    EasingCurve {
++                        id: snappingCurve
++                        type: EasingCurve.Linear
++                        period: (spreadView.positionMarker2 - spreadView.positionMarker1) / 3
++                        progress: spreadTile.progress - spreadView.positionMarker1
++                    }
++                }
++            }
++        }
++    }
++
++    EdgeDragArea {
++        id: spreadDragArea
++        anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
++        width: root.dragAreaWidth
++        direction: Direction.Leftwards
++
++        property bool attachedToView: false
++        property var gesturePoints: new Array()
++
++        onTouchXChanged: {
++            if (!dragging) {
++                spreadView.phase = 0;
++                spreadView.contentX = 0;
++            }
++
++            if (attachedToView) {
++                spreadView.contentX = -touchX + spreadDragArea.width;
++                if (spreadView.contentX > spreadView.phase0Width + spreadView.phase1Width / 2) {
++                    attachedToView = false;
++                    spreadView.snap();
++                }
++            }
++            gesturePoints.push(touchX);
++        }
++
++        onStatusChanged: {
++            if (status == DirectionalDragArea.Recognized) {
++                attachedToView = true;
++            }
++        }
++
++        onDraggingChanged: {
++            if (dragging) {
++                // Gesture recognized. Start recording this gesture
++                gesturePoints = [];
++                return;
++            }
++
++            // Ok. The user released. Find out if it was a one-way movement.
++            var oneWayFlick = priv.evaluateOneWayFlick(gesturePoints);
++            gesturePoints = [];
++
++            if (oneWayFlick && spreadView.contentX < spreadView.positionMarker1 * spreadView.width) {
++                // If it was a short one-way movement, do the Alt+Tab switch
++                // no matter if we didn't cross positionMarker1 yet.
++                spreadView.snapTo(spreadView.nextInStack);
++            } else if (!dragging && attachedToView) {
++                if (spreadView.contentX < spreadView.width * spreadView.positionMarker1) {
++                    spreadView.snap();
++                } else if (spreadView.contentX < spreadView.width * spreadView.positionMarker2) {
++                    spreadView.snapTo(spreadView.nextInStack);
++                } else {
++                    // otherwise snap to the closest snap position we can find
++                    // (might be back to start, to app 1 or to spread)
++                    spreadView.snap();
++                }
++            }
++        }
++    }
++}
 === modified file 'qml/Stages/TransformedSpreadDelegate.qml'
 --- qml/Stages/TransformedSpreadDelegate.qml	2014-03-19 19:10:30 +0000
 +++ qml/Stages/TransformedSpreadDelegate.qml	2014-07-29 14:07:22 +0000
@@ -23,7 +23,9 @@
  SpreadDelegate {
      id: root
++    // Set this to true when this tile is selected in the spread. The animation will change to bring the tile to front.
      property bool selected: false
++    // Set this to true when another tile in the spread is selected. The animation will change to fade this tile out.
      property bool otherSelected: false
      // The progress animates the tiles. A value > 0 makes it appear from the right edge. At 1 it reaches the end position.
@@ -44,6 +46,9 @@
      property real startDistance: units.gu(5)
      property real endDistance: units.gu(.5)
++    // Hiding tiles when their progress is negative or reached the maximum
++    visible: progress >= 0 && progress < 1.7
++
      onSelectedChanged: {
          if (selected) {
              priv.snapshot();
@@ -106,16 +111,6 @@
              selectedTopMarginProgress = topMarginProgress;
+         }
--        // This calculates how much negative progress there can be if unwinding the spread completely
--        // the progress for each tile starts at 0 when it crosses the right edge, so the later a tile comes in,
--        // the bigger its negativeProgress can be.
--        property real negativeProgress: {
--            if (index == 1 && spreadView.phase < 2) {
--                return 0;
--            }
--            return -index * spreadView.tileDistance / spreadView.width;
--        }
--
          function linearAnimation(startProgress, endProgress, startValue, endValue, progress) {
              // progress : progressDiff = value : valueDiff => value = progress * valueDiff / progressDiff
              return (progress - startProgress) * (endValue - startValue) / (endProgress - startProgress) + startValue;
@@ -127,22 +122,20 @@
              return helperEasingCurve.value * (endValue - startValue) + startValue;
+         }
--        property real animatedEndDistance: linearAnimation(0, 2, root.endDistance, 0, root.progress)
--
          // The following blocks handle the animation of the tile in the spread.
          // At the beginning, each tile is attached at the right edge, outside the screen.
          // The progress for each tile starts at 0 and it reaches its end position at a progress of 1.
--        // The first phases are handled special for the first 2 tiles. as we do the alt-tab and snapping in there
--        // Once we reached phase 3, the animation is the same for all tiles.
--        // When a tile is selected, the animation state is snapshotted, and the spreadView is unwound (progress animates
--        // back to negativeProgress). All tiles are kept in place and faded out to 0 opacity except
++        // The first phases are handled special for the first 2 tiles. as we do the alt-tab and snapping
++        // in there. Once we reached phase 3, the animation is the same for all tiles.
++        // When a tile is selected, the animation state is snapshotted, and the spreadView is unwound.
++        // All tiles are kept in place and faded out to 0 opacity except
          // the selected tile, which is animated from the snapshotted position to be fullscreen.
--        property real xTranslate: {
++        readonly property real xTranslate: {
              if (otherSelected) {
                  if (spreadView.phase < 2 && index == 0) {
--                    return linearAnimation(selectedProgress, negativeProgress,
--                                           selectedXTranslate, selectedXTranslate - spreadView.tileDistance, root.progress);
++                    return linearAnimation(selectedProgress, 0, selectedXTranslate,
++                                           selectedXTranslate - spreadView.tileDistance, root.progress);
+                 }
                  return selectedXTranslate;
@@ -160,7 +153,7 @@
                      // Apply the same animation as with the rest but add spreadView.width to align it with the others.
                      return -easingCurve.value * spreadView.width + spreadView.width;
                  } else if (priv.isSelected) {
--                    return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, 0, root.progress);
++                    return linearAnimation(selectedProgress, 0, selectedXTranslate, 0, root.progress);
+                 }
              case 1:
@@ -177,23 +170,28 @@
              if (priv.isSelected) {
                  // Distance to left edge
                  var targetTranslate = -spreadView.width - ((index - 1) * root.startDistance);
--                return linearAnimation(selectedProgress, negativeProgress,
++                return linearAnimation(selectedProgress, 0,
                                         selectedXTranslate, targetTranslate, root.progress);
+             }
              // Fix it at the right edge...
              var rightEdgeOffset =  -((index - 1) * root.startDistance);
              // ...and use our easing to move them to the left. Stop a bit earlier for each tile
++            var animatedEndDistance = linearAnimation(0, 2, root.endDistance, 0, root.progress);
              return -easingCurve.value * spreadView.width + (index * animatedEndDistance) + rightEdgeOffset;
+         }
--        property real angle: {
++        readonly property real angle: {
++            if (spreadView.focusChanging) {
++                return 0;
++            }
++
              if (priv.otherSelected) {
                  return priv.selectedAngle;
+             }
              if (priv.isSelected) {
--                return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);
++                return linearAnimation(selectedProgress, 0, selectedAngle, 0, root.progress);
+             }
              switch (index) {
              case 0:
@@ -217,12 +215,15 @@
              return root.startAngle - easingCurve.value * (root.startAngle - root.endAngle);
+         }
--        property real scale: {
++        readonly property real scale: {
++            if (spreadView.focusChanging) {
++                return 1;
++            }
              if (priv.otherSelected) {
                  return priv.selectedScale;
+             }
              if (priv.isSelected) {
--                return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);
++                return linearAnimation(selectedProgress, 0, selectedScale, 1, root.progress);
+             }
              switch (index) {
@@ -247,7 +248,7 @@
              return root.startScale - easingCurve.value * (root.startScale - root.endScale);
+         }
--        property real opacity: {
++        readonly property real opacity: {
              if (priv.otherSelected) {
                  return linearAnimation (selectedProgress, Math.max(0, selectedProgress - .5),
                                          selectedOpacity, 0, root.progress);
@@ -265,9 +266,9 @@
              return 1;
+         }
--        property real topMarginProgress: {
++        readonly property real topMarginProgress: {
              if (priv.isSelected) {
--                return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);
++                return linearAnimation(selectedProgress, 0, selectedTopMarginProgress, 0, root.progress);
+             }
              switch (index) {
@@ -290,6 +291,7 @@
              return easingCurve.value;
+         }
++
+     }
      transform: [
@@ -303,18 +305,22 @@
              xScale: priv.scale
              yScale: xScale
          },
++        Scale {
++            origin { x: 0; y: (spreadView.height * priv.scale) + maximizedAppTopMargin * 3 }
++            xScale: 1
++            yScale: isFullscreen ? 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height : 1
++        },
          Translate {
              x: priv.xTranslate
+         }
+     ]
      opacity: priv.opacity
--    topMarginProgress: priv.topMarginProgress
      EasingCurve {
          id: easingCurve
          type: EasingCurve.OutSine
          period: 1 - spreadView.positionMarker2
--        progress: root.animatedProgress
++        progress: root.progress
+     }
      // This is used as a calculation helper to figure values for progress other than the current one
 === added file 'qml/Stages/TransformedTabletSpreadDelegate.qml'
 --- qml/Stages/TransformedTabletSpreadDelegate.qml	1970-01-01 00:00:00 +0000
 +++ qml/Stages/TransformedTabletSpreadDelegate.qml	2014-07-29 14:07:22 +0000
@@ -0,0 +1,369 @@
++/*
++ * Copyright 2014 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License 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/>.
++ *
++ * Authors: Michael Zanetti <michael.zanetti@canonical.com>
++*/
++
++import QtQuick 2.0
++import Utils 0.1
++import Ubuntu.Components 0.1
++import Unity.Application 0.1
++
++SpreadDelegate {
++    id: root
++
++    // Set this to true when this tile is selected in the spread. The animation will change to bring the tile to front.
++    property bool selected: false
++    // Set this to true when another tile in the spread is selected. The animation will change to fade this tile out.
++    property bool otherSelected: false
++    // Set this to true when this tile a currently active on either the MS or the SS.
++    property bool active: false
++
++    property int zIndex
++    property real progress: 0
++    property real animatedProgress: 0
++
++    property real startDistance: units.gu(5)
++    property real endDistance: units.gu(.5)
++
++    property real startScale: 1.1
++    property real endScale: 0.7
++    property real dragStartScale: startScale + .2
++
++    property real startAngle: 15
++    property real endAngle: 5
++
++    property bool isInSideStage: false
++
++    onSelectedChanged: {
++        if (selected) {
++            priv.snapshot();
++        }
++        priv.isSelected = selected;
++    }
++
++    onOtherSelectedChanged: {
++        if (otherSelected) {
++            priv.snapshot();
++        }
++        priv.otherSelected = otherSelected;
++    }
++
++    Connections {
++        target: spreadView
++
++        onPhaseChanged: {
++            if (spreadView.phase == 1) {
++                var phase2Progress = spreadView.positionMarker4 - (root.zIndex * spreadView.tileDistance / spreadView.width);
++                priv.phase2StartTranslate = priv.easingAnimation(0, 1, 0, -spreadView.width + (root.zIndex * root.endDistance), phase2Progress);
++                priv.phase2StartScale = priv.easingAnimation(0, 1, root.startScale, root.endScale, phase2Progress);
++                priv.phase2StartAngle = priv.easingAnimation(0, 1, root.startAngle, root.endAngle, phase2Progress);
++                priv.phase2StartTopMarginProgress = priv.easingAnimation(0, 1, 0, 1, phase2Progress);
++            }
++        }
++    }
++
++    // Required to be an item because we're using states on it.
++    Item {
++        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
++        // 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)
++
++        property real phase2StartTranslate
++        property real phase2StartScale
++        property real phase2StartAngle
++        property real phase2StartTopMarginProgress
++
++        property bool isSelected: false
++        property bool otherSelected: false
++        property real selectedProgress
++        property real selectedXTranslate
++        property real selectedAngle
++        property real selectedScale
++        property real selectedOpacity
++        property real selectedTopMarginProgress
++
++        function snapshot() {
++            selectedProgress = root.progress;
++            selectedXTranslate = xTranslate;
++            selectedAngle = angle;
++            selectedScale = priv.scale;
++            selectedOpacity = priv.opacityTransform;
++            selectedTopMarginProgress = topMarginProgress;
++        }
++
++        // This calculates how much negative progress there can be if unwinding the spread completely
++        // the progress for each tile starts at 0 when it crosses the right edge, so the later a tile comes in,
++        // the bigger its negativeProgress can be.
++        property real negativeProgress: {
++            if (nextInStack && spreadView.phase < 2) {
++                return 0;
++            }
++            return -root.zIndex * spreadView.tileDistance / spreadView.width;
++        }
++
++        function linearAnimation(startProgress, endProgress, startValue, endValue, progress) {
++            // progress : progressDiff = value : valueDiff => value = progress * valueDiff / progressDiff
++            return (progress - startProgress) * (endValue - startValue) / (endProgress - startProgress) + startValue;
++        }
++
++        function easingAnimation(startProgress, endProgress, startValue, endValue, progress) {
++            helperEasingCurve.progress = progress - startProgress;
++            helperEasingCurve.period = endProgress - startProgress;
++            return helperEasingCurve.value * (endValue - startValue) + startValue;
++        }
++
++        property real xTranslate: {
++            var newTranslate = 0;
++
++            if (otherSelected) {
++                return priv.selectedXTranslate;
++            }
++
++            if (isSelected) {
++                if (model.stage == ApplicationInfoInterface.MainStage) {
++                    return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.width, root.progress);
++                } else {
++                    return linearAnimation(selectedProgress, negativeProgress, selectedXTranslate, -spreadView.sideStageWidth, root.progress);
++                }
++            }
++
++            // 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 && model.stage === ApplicationInfoInterface.MainStage &&
++                    ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage;
++
++            if (active) {
++                newTranslate -= root.width
++                // Only do the hide animation for active apps in the mainstage, and not if we only drag the ss in
++                if (spreadView.phase == 0 && shouldMoveAway) {
++                    newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -units.gu(4), root.animatedProgress);
++                }
++            }
++            if (nextInStack && spreadView.phase == 0) {
++                if (model.stage == ApplicationInfoInterface.MainStage) {
++                    if (spreadView.sideStageVisible && root.progress > 0) {
++                        // Move it so it appears from behind the side stage immediately
++                        newTranslate += -spreadView.sideStageWidth;
++                    }
++                }
++
++                if (model.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.progress);
++                } else {
++                    newTranslate += linearAnimation(0, spreadView.positionMarker2, 0, -spreadView.sideStageWidth * spreadView.snapPosition, root.animatedProgress);
++                }
++            }
++
++            if (spreadView.phase == 1) {
++                if (nextInStack) {
++                    if (model.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 {
++                        var endValue = -spreadView.width + spreadView.width * root.zIndex / 6;
++                        if (!spreadView.sideStageVisible) {
++                            newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, -spreadView.sideStageWidth, priv.phase2StartTranslate, root.progress);
++                        } else {
++                            newTranslate += linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, -spreadView.sideStageWidth * spreadView.snapPosition, priv.phase2StartTranslate, root.animatedProgress);
++                        }
++                    }
++                } else if (root.active) {
++                    var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
++                    var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
++                    var startTranslate = -root.width + (shouldMoveAway ? -units.gu(4) : 0);
++                    newTranslate = linearAnimation(startProgress, endProgress, startTranslate, priv.phase2StartTranslate, root.progress);
++                } else {
++                    var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
++                    var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
++                    newTranslate = linearAnimation(startProgress, endProgress, 0, priv.phase2StartTranslate, root.progress);
++                }
++            }
++
++            if (spreadView.phase == 2) {
++                newTranslate = -easingCurve.value * (spreadView.width - root.zIndex * animatedEndDistance);
++            }
++
++            return newTranslate;
++        }
++
++        property real scale: {
++            if (otherSelected) {
++                return selectedScale;
++            }
++
++            if (isSelected) {
++                return linearAnimation(selectedProgress, negativeProgress, selectedScale, 1, root.progress);
++            }
++
++            if (spreadView.phase == 0) {
++                if (nextInStack) {
++                    if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                        return 1;
++                    } else {
++                        var targetScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
++                        return linearAnimation(0, spreadView.positionMarker2, root.dragStartScale, targetScale, root.animatedProgress);
++                    }
++                } else if (active) {
++                    return 1;
++                } else {
++                    return linearAnimation(0, spreadView.positionMarker2, root.startScale, root.endScale, root.progress);
++                }
++            }
++
++            if (spreadView.phase == 1) {
++                if (nextInStack) {
++                    var startScale = 1;
++                    if (model.stage !== ApplicationInfoInterface.SideStage || spreadView.sideStageVisible) {
++                        startScale = root.dragStartScale - ((root.dragStartScale - 1) * spreadView.snapPosition);
++                    }
++                    return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4, startScale, priv.phase2StartScale, root.animatedProgress);
++                }
++                var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
++                var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
++                return linearAnimation(startProgress, endProgress, 1, priv.phase2StartScale, root.animatedProgress);
++            }
++
++            if (spreadView.phase == 2) {
++                return root.startScale - easingCurve.value * (root.startScale - root.endScale);
++            }
++
++            return 1;
++        }
++
++        property real angle: {
++            if (otherSelected) {
++                return selectedAngle;
++            }
++            if (isSelected) {
++                return linearAnimation(selectedProgress, negativeProgress, selectedAngle, 0, root.progress);
++            }
++
++            // 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 >= 0 && movedActive &&
++                    (ApplicationManager.get(spreadView.nextInStack).stage === ApplicationInfoInterface.MainStage ||
++                     model.stage == ApplicationInfoInterface.SideStage);
++
++            if (spreadView.phase == 0) {
++                if (nextInStack) {
++                    if (model.stage == ApplicationInfoInterface.SideStage && !spreadView.sideStageVisible) {
++                        return 0;
++                    } else {
++                        return linearAnimation(0, spreadView.positionMarker2, root.startAngle, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);
++                    }
++                }
++                if (shouldMoveAway) {
++                    return linearAnimation(0, spreadView.positionMarker2, 0, root.startAngle * (1-spreadView.snapPosition), root.animatedProgress);
++                }
++            }
++            if (spreadView.phase == 1) {
++                if (nextInStack) {
++                    if (model.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);
++                    }
++                }
++                var startProgress = spreadView.positionMarker2 - (zIndex * spreadView.positionMarker2 / 2);
++                var endProgress = spreadView.positionMarker4 - (zIndex * spreadView.tileDistance / spreadView.width);
++                var startAngle = shouldMoveAway ? root.startAngle * (1-spreadView.snapPosition) : 0;
++                return linearAnimation(startProgress, endProgress, startAngle, priv.phase2StartAngle, root.progress);
++            }
++            if (spreadView.phase == 2) {
++                return root.startAngle - easingCurve.value * (root.startAngle - root.endAngle);
++            }
++
++            return 0;
++        }
++
++        property real opacityTransform: {
++            if (otherSelected && spreadView.phase == 2) {
++                return linearAnimation(selectedProgress, negativeProgress, selectedOpacity, 0, root.progress);
++            }
++
++            return 1;
++        }
++
++        property real topMarginProgress: {
++            if (priv.isSelected) {
++                return linearAnimation(selectedProgress, negativeProgress, selectedTopMarginProgress, 0, root.progress);
++            }
++            switch (spreadView.phase) {
++            case 0:
++                return 0;
++            case 1:
++                return linearAnimation(spreadView.positionMarker2, spreadView.positionMarker4,
++                                       0, priv.phase2StartTopMarginProgress, root.progress);
++            }
++            return 1;
++        }
++
++        states: [
++            State {
++                name: "sideStageDragging"; when: spreadView.sideStageDragging && root.isInSideStage
++                PropertyChanges { target: priv; xTranslate: -spreadView.sideStageWidth + spreadView.sideStageWidth * spreadView.sideStageDragProgress }
++            }
++        ]
++    }
++
++    transform: [
++        Rotation {
++            origin { x: 0; y: spreadView.height / 2 }
++            axis { x: 0; y: 1; z: 0 }
++            angle: priv.angle
++        },
++        Scale {
++            origin { x: 0; y: spreadView.height / 2 }
++            xScale: priv.scale
++            yScale: xScale
++        },
++        Scale {
++            origin { x: 0; y: (spreadView.height * priv.scale) + maximizedAppTopMargin * 3 }
++            xScale: 1
++            yScale: isFullscreen ? 1 - priv.topMarginProgress * maximizedAppTopMargin / spreadView.height : 1
++        },
++        Translate {
++            x: priv.xTranslate
++        }
++    ]
++    opacity: priv.opacityTransform
++
++    UbuntuNumberAnimation {
++        id: fadeBackInAnimation
++        target: root
++        property: "opacity"
++        duration: UbuntuAnimation.SlowDuration
++        from: 0
++        to: 1
++    }
++
++    EasingCurve {
++        id: easingCurve
++        type: EasingCurve.OutSine
++        period: 1
++        progress: root.progress
++    }
++
++    EasingCurve {
++        id: helperEasingCurve
++        type: easingCurve.type
++        period: easingCurve.period
++    }
++}
 === modified file 'src/CMakeLists.txt'
 --- src/CMakeLists.txt	2014-06-30 12:46:04 +0000
 +++ src/CMakeLists.txt	2014-07-29 14:07:22 +0000
@@ -1,8 +1,5 @@
--pkg_check_modules(UNITY-MIR REQUIRED unity-mir)
--
  include_directories(
      ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
--    ${UNITY-MIR_INCLUDE_DIRS}
+ )
  file(GLOB_RECURSE QML_FILES
 === modified file 'src/main.cpp'
 --- src/main.cpp	2014-07-22 12:46:06 +0000
 +++ src/main.cpp	2014-07-29 14:07:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2012 Canonical, Ltd.
++ * Copyright (C) 2012-2014 Canonical, Ltd.
+  *
   * Authors:
   *  Gerry Boland <gerry.boland@canonical.com>
@@ -23,12 +23,9 @@
  #include <QtGui/QGuiApplication>
  #include <QtQml/QQmlEngine>
  #include <QtQml/QQmlContext>
--#include <qpa/qplatformnativeinterface.h>
  #include <QLibrary>
  #include <QDebug>
  #include <libintl.h>
--#include <dlfcn.h>
--#include <csignal>
  // local
  #include <paths.h>
@@ -36,11 +33,13 @@
  #include "ApplicationArguments.h"
  #include "CachingNetworkManagerFactory.h"
--#include <unity-mir/qmirserver.h>
--
--int startShell(int argc, const char** argv, void* server)
++int main(int argc, const char *argv[])
+ {
--    const bool isUbuntuMirServer = qgetenv("QT_QPA_PLATFORM") == "ubuntumirserver";
++    bool isMirServer = false;
++    if (qgetenv("QT_QPA_PLATFORM") == "ubuntumirclient") {
++        setenv("QT_QPA_PLATFORM", "mirserver", 1 /* overwrite */);
++        isMirServer = true;
++    }
      QGuiApplication::setApplicationName("unity8");
      QGuiApplication *application;
@@ -70,21 +69,7 @@
  Load the testability driver");
      parser.addOption(testabilityOption);
--    if (isUbuntuMirServer) {
--        QLibrary unityMir("unity-mir", 1);
--        unityMir.load();
--
--        typedef QGuiApplication* (*createServerApplication_t)(int&, const char **, void*);
--        createServerApplication_t createQMirServerApplication = (createServerApplication_t) unityMir.resolve("createQMirServerApplication");
--        if (!createQMirServerApplication) {
--            qDebug() << "unable to resolve symbol: createQMirServerApplication";
--            return 4;
--        }
--
--        application = createQMirServerApplication(argc, argv, server);
--    } else {
--        application = new QGuiApplication(argc, (char**)argv);
--    }
++    application = new QGuiApplication(argc, (char**)argv);
      // Treat args with single dashes the same as arguments with two dashes
      // Ex: -fullscreen == --fullscreen
@@ -100,8 +85,8 @@
      if (parser.isSet(windowGeometryOption) &&
          parser.value(windowGeometryOption).split('x').size() == 2)
+     {
--      QStringList geom = parser.value(windowGeometryOption).split('x');
--      qmlArgs.setSize(geom.at(0).toInt(), geom.at(1).toInt());
++        QStringList geom = parser.value(windowGeometryOption).split('x');
++        qmlArgs.setSize(geom.at(0).toInt(), geom.at(1).toInt());
+     }
      // The testability driver is only loaded by QApplication but not by QGuiApplication.
@@ -125,7 +110,8 @@
      QQuickView* view = new QQuickView();
      view->setResizeMode(QQuickView::SizeRootObjectToView);
--    view->setTitle("Qml Phone Shell");
++    view->setColor("black");
++    view->setTitle("Unity8 Shell");
      view->engine()->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));
      view->rootContext()->setContextProperty("applicationArguments", &qmlArgs);
      view->rootContext()->setContextProperty("indicatorProfile", indicatorProfile);
@@ -141,18 +127,9 @@
          application->installNativeEventFilter(mouseTouchAdaptor);
+     }
--    QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
--    /* Shell is declared as a system session so that it always receives all
--       input events.
--       FIXME: use the enum value corresponding to SYSTEM_SESSION_TYPE (= 1)
--       when it becomes available.
--    */
--    nativeInterface->setProperty("ubuntuSessionType", 1);
--    view->setProperty("role", 2); // INDICATOR_ACTOR_ROLE
--
      QUrl source(::qmlDirectory()+"Shell.qml");
      prependImportPaths(view->engine(), ::overrideImportPaths());
--    if (!isUbuntuMirServer) {
++    if (!isMirServer) {
          prependImportPaths(view->engine(), ::nonMirImportPaths());
+     }
      appendImportPaths(view->engine(), ::fallbackImportPaths());
@@ -161,10 +138,9 @@
      view->engine()->setNetworkAccessManagerFactory(managerFactory);
      view->setSource(source);
--    view->setColor("transparent");
      QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
--    if (qgetenv("QT_QPA_PLATFORM") == "ubuntu" || isUbuntuMirServer || parser.isSet(fullscreenOption)) {
++    if (isMirServer || parser.isSet(fullscreenOption)) {
          view->showFullScreen();
      } else {
          view->show();
@@ -178,54 +154,3 @@
      return result;
+ }
--
--int main(int argc, const char *argv[])
--{
--    /* Workaround Qt platform integration plugin not advertising itself
--       as having the following capabilities:
--        - QPlatformIntegration::ThreadedOpenGL
--        - QPlatformIntegration::BufferQueueingOpenGL
--    */
--    setenv("QML_FORCE_THREADED_RENDERER", "1", 1);
--    setenv("QML_FIXED_ANIMATION_STEP", "1", 1);
--
--    // For ubuntumirserver/ubuntumirclient
--    if (qgetenv("QT_QPA_PLATFORM").startsWith("ubuntumir")) {
--        setenv("QT_QPA_PLATFORM", "ubuntumirserver", 1);
--
--        // If we use unity-mir directly, we automatically link to the Mir-server
--        // platform-api bindings, which result in unexpected behaviour when
--        // running the non-Mir scenario.
--        QLibrary unityMir("unity-mir", 1);
--        unityMir.load();
--        if (!unityMir.isLoaded()) {
--            qDebug() << "Library unity-mir not found/loaded";
--            return 1;
--        }
--
--        typedef QMirServer* (*createServer_t)(int, const char **);
--        createServer_t createQMirServer = (createServer_t) unityMir.resolve("createQMirServer");
--        if (!createQMirServer) {
--            qDebug() << "unable to resolve symbol: createQMirServer";
--            return 2;
--        }
--
--        QMirServer* mirServer = createQMirServer(argc, argv);
--
--        typedef int (*runWithClient_t)(QMirServer*, std::function<int(int, const char**, void*)>);
--        runWithClient_t runWithClient = (runWithClient_t) unityMir.resolve("runQMirServerWithClient");
--        if (!runWithClient) {
--            qDebug() << "unable to resolve symbol: runWithClient";
--            return 3;
--        }
--
--        return runWithClient(mirServer, startShell);
--    } else {
--        if (!qgetenv("UNITY_MIR_EMITS_SIGSTOP").isEmpty()) {
--            // Emit SIGSTOP as expected by upstart, under Mir it's unity-mir that will raise it.
--            // see http://upstart.ubuntu.com/cookbook/#expect-stop
--            raise(SIGSTOP);
--        }
--        return startShell(argc, argv, nullptr);
--    }
--}
 === modified file 'tests/mocks/Unity/Application/Application.qmltypes'
 --- tests/mocks/Unity/Application/Application.qmltypes	2014-06-26 08:26:58 +0000
 +++ tests/mocks/Unity/Application/Application.qmltypes	2014-07-29 14:07:22 +0000
@@ -102,8 +102,6 @@
                  "ForceMainStage": 1
+             }
+         }
--        Property { name: "keyboardHeight"; type: "int"; isReadonly: true }
--        Property { name: "keyboardVisible"; type: "bool"; isReadonly: true }
          Property { name: "sideStageWidth"; type: "int"; isReadonly: true }
          Property { name: "stageHint"; type: "StageHint"; isReadonly: true }
          Property { name: "formFactorHint"; type: "FormFactorHint"; isReadonly: true }
 === added file 'tests/mocks/Unity/Application/ApplicationDBusAdaptor.cpp'
 --- tests/mocks/Unity/Application/ApplicationDBusAdaptor.cpp	1970-01-01 00:00:00 +0000
 +++ tests/mocks/Unity/Application/ApplicationDBusAdaptor.cpp	2014-07-29 14:07:22 +0000
@@ -0,0 +1,75 @@
++/*
++ * 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/>.
++ */
++
++#include "ApplicationInfo.h"
++#include "ApplicationDBusAdaptor.h"
++#include "ApplicationManager.h"
++#include "SurfaceManager.h"
++#include "MirSurfaceItem.h"
++
++quint32 nextId = 0;
++
++ApplicationDBusAdaptor::ApplicationDBusAdaptor(ApplicationManager* applicationManager)
++    : QDBusAbstractAdaptor(applicationManager)
++    , m_applicationManager(applicationManager)
++{
++}
++
++MirSurfaceItem* topSurface(MirSurfaceItem* surface)
++{
++    if (!surface)
++        return nullptr;
++
++    MirSurfaceItem* child = NULL;
++    Q_FOREACH (MirSurfaceItem *childSurface, surface->childSurfaceList()) {
++        child = topSurface(childSurface);
++        if (child) {
++            break;
++        }
++    }
++    return child ? child : surface;
++}
++
++quint32 ApplicationDBusAdaptor::addChildSurface(const QString &appId, const QString &surfaceImage)
++{
++    qDebug() << "ApplicationDBusAdaptor::addChildSurface - " << appId;
++
++    ApplicationInfo* application = m_applicationManager->findApplication(appId);
++    if (!application) {
++        qDebug() << "ApplicationDBusAdaptor::addChildSurface - No application found for " << appId;
++        return 0;
++    }
++    quint32 surfaceId = ++nextId;
++    MirSurfaceItem* surface = new MirSurfaceItem(QString("ChildSurface%1").arg(surfaceId),
++                                                 MirSurfaceItem::Normal,
++                                                 MirSurfaceItem::Maximized,
++                                                 QUrl(surfaceImage));
++    m_childItems[surfaceId] = surface;
++    surface->setParentSurface(topSurface(application->surface()));
++    return surfaceId;
++}
++
++void ApplicationDBusAdaptor::removeChildSurface(int surfaceId)
++{
++    qDebug() << "ApplicationDBusAdaptor::removeChildSurface - " << surfaceId;
++
++    if (!m_childItems.contains(surfaceId)) {
++        qDebug() << "ApplicationDBusAdaptor::removeChildSurface - No added surface for " << surfaceId;
++        return;
++    }
++    MirSurfaceItem* surface = m_childItems.take(surfaceId);
++    Q_EMIT surface->removed();
++}
 === added file 'tests/mocks/Unity/Application/ApplicationDBusAdaptor.h'
 --- tests/mocks/Unity/Application/ApplicationDBusAdaptor.h	1970-01-01 00:00:00 +0000
 +++ tests/mocks/Unity/Application/ApplicationDBusAdaptor.h	2014-07-29 14:07:22 +0000
@@ -0,0 +1,43 @@
++/*
++ * Copyright (C) 2014 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU 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 APPLICATIONDBUSADAPTOR_H
++#define APPLICATIONDBUSADAPTOR_H
++
++#include <QtDBus/QtDBus>
++
++class ApplicationManager;
++class SurfaceManager;
++class MirSurfaceItem;
++
++class ApplicationDBusAdaptor : public QDBusAbstractAdaptor
++{
++    Q_OBJECT
++    Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity8.Mocks.Application")
++public:
++    ApplicationDBusAdaptor(ApplicationManager* applicationManager);
++
++public Q_SLOTS:
++    quint32 addChildSurface(const QString& appId, const QString& surfaceImage);
++    void removeChildSurface(int surfaceId);
++
++private:
++    ApplicationManager* m_applicationManager;
++
++    QHash<quint32, MirSurfaceItem*> m_childItems;
++};
++
++#endif // APPLICATIONDBUSADAPTOR_H
 === modified file 'tests/mocks/Unity/Application/ApplicationInfo.cpp'
 --- tests/mocks/Unity/Application/ApplicationInfo.cpp	2014-03-20 10:02:52 +0000
 +++ tests/mocks/Unity/Application/ApplicationInfo.cpp	2014-07-29 14:07:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013 Canonical, Ltd.
++ * Copyright (C) 2013-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
@@ -15,6 +15,8 @@
   */
  #include "ApplicationInfo.h"
++#include "MirSurfaceItem.h"
++#include "SurfaceManager.h"
  #include <QGuiApplication>
  #include <QQuickItem>
@@ -24,29 +26,39 @@
  ApplicationInfo::ApplicationInfo(const QString &appId, QObject *parent)
      : ApplicationInfoInterface(appId, parent)
--    ,m_appId(appId)
--    ,m_stage(MainStage)
--    ,m_state(Starting)
--    ,m_focused(false)
--    ,m_fullscreen(false)
--    ,m_windowItem(0)
--    ,m_windowComponent(0)
--    ,m_parentItem(0)
++    , m_appId(appId)
++    , m_stage(MainStage)
++    , m_state(Starting)
++    , m_focused(false)
++    , m_fullscreen(false)
++    , m_windowItem(0)
++    , m_windowComponent(0)
++    , m_parentItem(0)
++    , m_surface(0)
+ {
--    QTimer::singleShot(300, this, SLOT(setRunning()));
++    connect(this, &ApplicationInfo::stateChanged, this, &ApplicationInfo::onStateChanged);
+ }
  ApplicationInfo::ApplicationInfo(QObject *parent)
      : ApplicationInfoInterface(QString(), parent)
--     ,m_stage(MainStage)
--     ,m_state(Starting)
--     ,m_focused(false)
--     ,m_fullscreen(false)
--     ,m_windowItem(0)
--     ,m_windowComponent(0)
--     ,m_parentItem(0)
--{
--    QTimer::singleShot(300, this, SLOT(setRunning()));
++    , m_stage(MainStage)
++    , m_state(Starting)
++    , m_focused(false)
++    , m_fullscreen(false)
++    , m_windowItem(0)
++    , m_windowComponent(0)
++    , m_parentItem(0)
++    , m_surface(0)
++{
++    connect(this, &ApplicationInfo::stateChanged, this, &ApplicationInfo::onStateChanged);
++}
++
++ApplicationInfo::~ApplicationInfo()
++{
++    if (m_surface) {
++        Q_EMIT SurfaceManager::singleton()->surfaceDestroyed(m_surface);
++        m_surface->deleteLater();
++    }
+ }
  void ApplicationInfo::onWindowComponentStatusChanged(QQmlComponent::Status status)
@@ -55,10 +67,46 @@
          doCreateWindowItem();
+ }
--void ApplicationInfo::setRunning()
--{
--    m_state = Running;
--    Q_EMIT stateChanged();
++void ApplicationInfo::onStateChanged(State state)
++{
++    if (state == ApplicationInfo::Running) {
++        QTimer::singleShot(1000, this, SLOT(createSurface()));
++    } else if (state == ApplicationInfo::Stopped) {
++        setSurface(nullptr);
++    }
++}
++
++void ApplicationInfo::createSurface()
++{
++    if (m_surface || state() == ApplicationInfo::Stopped) return;
++
++    setSurface(new MirSurfaceItem(name(),
++                                   MirSurfaceItem::Normal,
++                                   fullscreen() ? MirSurfaceItem::Fullscreen : MirSurfaceItem::Maximized,
++                                   screenshot()));
++}
++
++void ApplicationInfo::setSurface(MirSurfaceItem* surface)
++{
++    if (m_surface == surface)
++        return;
++
++    if (m_surface) {
++        m_surface->setApplication(nullptr);
++        m_surface->setParent(nullptr);
++        SurfaceManager::singleton()->unregisterSurface(m_surface);
++    }
++
++    m_surface = surface;
++
++    if (m_surface) {
++        m_surface->setApplication(this);
++        m_surface->setParent(this);
++        SurfaceManager::singleton()->registerSurface(m_surface);
++    }
++
++    Q_EMIT surfaceChanged(m_surface);
++    SurfaceManager::singleton()->registerSurface(m_surface);
+ }
  void ApplicationInfo::createWindowComponent()
 === modified file 'tests/mocks/Unity/Application/ApplicationInfo.h'
 --- tests/mocks/Unity/Application/ApplicationInfo.h	2014-03-20 10:02:52 +0000
 +++ tests/mocks/Unity/Application/ApplicationInfo.h	2014-07-29 14:07:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013 Canonical, Ltd.
++ * Copyright (C) 2013-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
@@ -21,6 +21,7 @@
  #include <QQmlComponent>
  class QQuickItem;
++class MirSurfaceItem;
  // unity-api
  #include <unity/shell/application/ApplicationInfoInterface.h>
@@ -36,6 +37,7 @@
      Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged)
      Q_PROPERTY(Stage stage READ stage WRITE setStage NOTIFY stageChanged)
++    Q_PROPERTY(MirSurfaceItem* surface READ surface NOTIFY surfaceChanged)
      // Only exists in this fake implementation
@@ -45,9 +47,10 @@
      // QML component used to represent the application window
      Q_PROPERTY(QString windowQml READ windowQml WRITE setWindowQml NOTIFY windowQmlChanged)
-- public:
++public:
      ApplicationInfo(QObject *parent = NULL);
      ApplicationInfo(const QString &appId, QObject *parent = NULL);
++    ~ApplicationInfo();
      #define IMPLEMENT_PROPERTY(name, Name, type) \
      public: \
@@ -56,11 +59,11 @@
      { \
          if (m_##name != value) { \
              m_##name = value; \
--            Q_EMIT name##Changed(); \
++            Q_EMIT name##Changed(value); \
          } \
      } \
      Q_SIGNALS: \
--    void name##Changed(); \
++    void name##Changed(const type&); \
      private: \
      type m_##name;
@@ -78,21 +81,31 @@
      #undef IMPLEMENT_PROPERTY
-- public:
++public:
++    void setSurface(MirSurfaceItem* surface);
++    MirSurfaceItem* surface() const { return m_surface; }
++
++Q_SIGNALS:
++    void surfaceChanged(MirSurfaceItem*);
++
++public:
      void showWindow(QQuickItem *parent);
      void hideWindow();
-- private Q_SLOTS: