Unity 8

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

mouseEdgePush
Merge into trunk

Proposed by Daniel d'Andrada on 2015-10-30

Status:	Superseded
Proposed branch:	lp:~dandrader/unity8/mouseEdgePush
Merge into:	lp:unity8
Prerequisite:	lp:~dandrader/unity8/cursorStartup
Diff against target:	2832 lines (+1243/-372) 40 files modified data/com.canonical.Unity8.gschema.xml (+16/-0) plugins/Cursor/MousePointer.cpp (+2/-0) plugins/Cursor/MousePointer.h (+4/-0) plugins/Utils/EdgeBarrierSettings.qml (+66/-0) plugins/Utils/qmldir (+1/-0) qml/Components/EdgeBarrier.qml (+111/-0) qml/Components/EdgeBarrierController.qml (+71/-0) qml/Components/PanelState/PanelState.qml (+3/-2) qml/Components/WindowControlButtons.qml (+76/-31) qml/Components/graphics/window-close.svg (+14/-0) qml/Components/graphics/window-maximize.svg (+12/-0) qml/Components/graphics/window-minimize.svg (+13/-0) qml/Launcher/Launcher.qml (+30/-32) qml/Launcher/LauncherPanel.qml (+7/-0) qml/Panel/Handle.qml (+2/-2) qml/Panel/Indicators/client/IndicatorsClient.qml (+1/-1) qml/Panel/IndicatorsMenu.qml (+11/-2) qml/Panel/MenuContent.qml (+1/-1) qml/Panel/Panel.qml (+68/-80) qml/Panel/PanelBackground.qml (+0/-21) qml/Shell.qml (+13/-0) qml/Stages/ApplicationWindow.qml (+29/-3) qml/Stages/DecoratedWindow.qml (+24/-16) qml/Stages/DesktopSpread.qml (+5/-19) qml/Stages/DesktopStage.qml (+107/-55) qml/Stages/SessionContainer.qml (+25/-1) qml/Stages/SurfaceContainer.qml (+56/-4) qml/Stages/WindowDecoration.qml (+15/-10) qml/Stages/WindowResizeArea.qml (+66/-21) tests/mocks/Cursor/Cursor.qml (+2/-0) tests/mocks/Unity/Application/MirSurface.cpp (+52/-0) tests/mocks/Unity/Application/MirSurface.h (+16/-0) tests/mocks/Utils/EdgeBarrierSettings.qml (+22/-0) tests/mocks/Utils/qmldir (+1/-0) tests/qmltests/EdgeBarrierControls.qml (+97/-0) tests/qmltests/Launcher/tst_Launcher.qml (+15/-5) tests/qmltests/Panel/tst_Panel.qml (+45/-11) tests/qmltests/Stages/tst_DesktopStage.qml (+96/-31) tests/qmltests/Stages/tst_WindowResizeArea.qml (+31/-12) tests/qmltests/tst_Shell.qml (+17/-12)
To merge this branch:	bzr merge lp:~dandrader/unity8/mouseEdgePush
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Michael Zanetti (community)		2015-10-30	Approve on 2015-11-23
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-11-23
Albert Astals Cid (community)	merges fine		Abstain on 2015-11-20
Review via email: mp+276306@code.launchpad.net

This proposal has been superseded by a proposal from 2015-11-24.

Commit Message

Mouse has to push against edges to show launcher or apps spread

edge-barrier-sensitivity is the property that should show up in the System Settings GUI.

edge-barrier-min-push and edge-barrier-max-push are exposed in GSettings merely as a convenience so you can tweak those values without having to restart unity8. But they should NOT show up in system settings.

Description of the Change

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

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

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

* If you changed the UI, has there been a design review?
John Lea tried it out. Values for the edge barrier parameters are still preliminary. Proper values will come once we have configurable mouse pointer speed and, most importantly, mouse pointer acceleration.

The graphical effect is following the design specification.

PS Jenkins bot (ps-jenkins) wrote on 2015-11-01:

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

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2015-11-02:

There's a few qmluitests that fail to compile

Daniel d'Andrada (dandrader) wrote on 2015-11-03:

> There's a few qmluitests that fail to compile

Fixed.

PS Jenkins bot (ps-jenkins) wrote on 2015-11-03:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-04

2022. By Daniel d'Andrada on 2015-11-04

Use SDK 1.3 across all files Fixes: #1449628, #1503498, #1508363
Approved by: PS Jenkins bot

2023. By Andrea Cimitan on 2015-11-04

Updated all 1.3 UbuntuShape to use new APIs where possible
Approved by: Albert Astals Cid

2024. By Andrea Cimitan on 2015-11-04

Make zoomable and video playback widgets edge to edge
Approved by: Albert Astals Cid

2025. By Andrea Cimitan on 2015-11-04

Add sharing widget to zoomable image and video playback
Approved by: Albert Astals Cid, Pawel Stolowski

2026. By Albert Astals Cid on 2015-11-04

Make the scope settings list scroll to text visible area
Fixes: #1499084
Approved by: Michael Terry

2027. By Albert Astals Cid on 2015-11-04

Move to importing QtQuick 2.4 & friends

This means we obviously require Qt 5.4 or greater, we had for a while
but make it official now
Approved by: Michael Terry

2028. By Albert Astals Cid on 2015-11-04

Add an Item that proxies for old and new audio roles Fixes: #1493851

2029. By Michael Zanetti on 2015-11-04

Fixes for the panel buttons

* Hide panel buttons when switching to staged mode
* properly save/restore window states, not just geometry Fixes: #1431566, #1443319, #1504269, #1510360
Approved by: Lukáš Tinkl

2030. By Michał Sawicz on 2015-11-04

Enable support for overriding application orientations based on device type Fixes: #1478637

2031. By Michael Terry on 2015-11-04

Handle lifecycle policy exceptions ourselves, instead of letting qtmir do it for us and allow non-Touch apps to opt-out of the Touch lifecycle.

This requires using the new isTouchApp unity-api property to ApplicationInfoInterface.

Now that qtmir won't decide policy for suspending exemptions anymore, we take over the interpretation of the lifecycleException GSettings key. Since the GSettings key for that was registered under the qtmir namespace (and there's no technical reason to migrate settings), I left the schema in qtmir itself. We merely consume it.

2032. By Michał Sawicz on 2015-11-04

Support server->client visibility change to stop rendering (lp:#1475678) Fixes: #1475678
Approved by: Daniel d'Andrada

2033. By Christopher Lee on 2015-11-04

Quick spelling fix in process control output.
Approved by: Albert Astals Cid

2034. By Albert Astals Cid on 2015-11-04

CroppedImageMinimumSourceSize: Fix 'Binding loop detected for property "imageAspectRatio"'

Approved by: Gerry Boland, Michał Sawicz

2035. By Michael Terry on 2015-11-04

Avoid showing the shutdown dialog when turning on the screen if your device is under heavy load.

Specifically, we actually watch the timestamp of input events as they come in to determine how long it's been. This means that if for whatever reason, processing of events get delayed, we don't misinterpret user input.

To test this, try running the following command and then turning the screen on and off again:
sudo cpulimit -l 1 -c 1 -p `ps ax | grep dbus-daemon | head -n 1 | awk '{print $1;}'`

Without this branch, you'll notice that at some point, you see the shutdown dialog in error. Because unity8 couldn't keep up with events and thought 2s passed between power-pressed and power-released events.

But if we watch the timestamps, we can avoid that particular fate. Fixes: #1508563
Approved by: Albert Astals Cid, Michael Zanetti

2036. By CI Train Bot Account on 2015-11-04

Releasing 8.11+16.04.20151104-0ubuntu1

PS Jenkins bot (ps-jenkins) wrote on 2015-11-04:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-11-05:

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

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2015-11-06:

Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
1 conflicts encountered.

Michael Zanetti (mzanetti) wrote on 2015-11-06:

Hmm... curious why we need 3 settings for this. Wouldn't one be enough? For instance, sensitivity, going from 0 to 100, which defines the grid units to be pushed... You probably do have a reason for this, what is it?

========

The shadow on the right edge looks very wrong. And I have a feeling it's too strong on the left edge too. You sure someone from design saw this? I know John didn't so far.

====
+ anchors.top: {
+ if (edge == Qt.LeftEdge || edge == Qt.RightEdge) {
+ return target.top;
+ } else {
+ return undefined;
+ }
+ }

writing this like this:

anchors.top: edge == Qt.LeftEdge || edge == Qt.RightEdge ? target.top : undefined

is quite a bit faster in evaluating. You should avoid adding JS blocks for bindings unless the other approach really ends up being unreadable.

======

+ // to be overwritten by tests
+ property bool _containsMouse: root.containsMouse

I'm starting to think you are mocking too much. Instead of all that logic with _containsMouse, wouldn't it be nicer to just use the standard containsMouse and in the test just do a mouseMove to fulfill that?

====

+ property real _defaultMinPushThreshold :
+ property real _minPushThreshold:
+ property real _maxPushThreshold:
+ property real _accumulatedPush:

instead of all those _properties everywhere, didn't we agree to put them into private objects instead?

====

I feel like EdgeBarrierSettings isn't needed at all. The tiny bit of logic could happen in EdgeBarrier.qml too, and for mocking the settings, we already have a fully mocked GSettings backend in tests/mocks/GSettings-1.0/ which you could reuse.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> Review: Needs Fixing
>
> Hmm... curious why we need 3 settings for this. Wouldn't one be enough? For instance, sensitivity, going from 0 to 100, which defines the grid units to be pushed... You probably do have a reason for this, what is it?
>

It's explained in the commit message

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> + // to be overwritten by tests
> + property bool _containsMouse: root.containsMouse
>
> I'm starting to think you are mocking too much. Instead of all that logic with _containsMouse, wouldn't it be nicer to just use the standard containsMouse and in the test just do a mouseMove to fulfill that?

I've to mock this in order to *manually* test edge barriers. Can't do
otherwise. See EdgeBarrierControls. Run "make tryLauncher".

The automated tests do not overwrite this property and do the
mouseMove() just like you mentioned.

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> I feel like EdgeBarrierSettings isn't needed at all. The tiny bit of logic could happen in EdgeBarrier.qml too, and for mocking the settings, we already have a fully mocked GSettings backend in tests/mocks/GSettings-1.0/ which you could reuse.

This is to avoid doing the same work several times. This settings stuff
is a singleton and thus is calculated/evaluated only once. Whereas you
can save several EdgeBarrier instances. So yes, we don't *need* to have
it separate, but it is more efficient that way.

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> The shadow on the right edge looks very wrong. And I have a feeling it's too strong on the left edge too. You sure someone from design saw this? I know John didn't so far.

The right edge and left edge shadows are the very same, just mirrored.
John Lea saw that (as I commented on the merge description). It puzzles
me to heard you say he did not...
By "wrong" you mean they're too opaque? Let's talk over IRC

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 08:09, Albert Astals Cid wrote:
> Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
> 1 conflicts encountered.
Fixed, thanks.

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> + property real _defaultMinPushThreshold :
> + property real _minPushThreshold:
> + property real _maxPushThreshold:
> + property real _accumulatedPush:
>
> instead of all those _properties everywhere, didn't we agree to put them into private objects instead?

Done.

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 09:48, Michael Zanetti wrote:
> writing this like this:
>
> anchors.top: edge == Qt.LeftEdge || edge == Qt.RightEdge ? target.top : undefined
>
> is quite a bit faster in evaluating. You should avoid adding JS blocks for bindings unless the other approach really ends up being unreadable.

Isn't that Javascript all the same, but just in a more concise notation?

Michael Zanetti (mzanetti) wrote on 2015-11-06:

On 06.11.2015 14:12, Daniel d'Andrada wrote:
> On 06/11/2015 09:48, Michael Zanetti wrote:
>> writing this like this:
>>
>> anchors.top: edge == Qt.LeftEdge || edge == Qt.RightEdge ? target.top : undefined
>>
>> is quite a bit faster in evaluating. You should avoid adding JS blocks for bindings unless the other approach really ends up being unreadable.
>
> Isn't that Javascript all the same, but just in a more concise notation?
>

From http://doc.qt.io/qt-5/qtquick-performance.html#javascript-code

"There are two types of bindings in QML: optimized and non-optimized
bindings.
...
Things to avoid in binding expressions to maximize optimizability:
...
* constructing closures or defining functions within the binding expression"

If I understand that correctly, adding {} already breaks some optimizations.

Daniel d'Andrada (dandrader) wrote on 2015-11-06:

On 06/11/2015 11:30, Michael Zanetti wrote:
>
> On 06.11.2015 14:12, Daniel d'Andrada wrote:
>> On 06/11/2015 09:48, Michael Zanetti wrote:
>>> writing this like this:
>>>
>>> anchors.top: edge == Qt.LeftEdge || edge == Qt.RightEdge ? target.top : undefined
>>>
>>> is quite a bit faster in evaluating. You should avoid adding JS blocks for bindings unless the other approach really ends up being unreadable.
>> Isn't that Javascript all the same, but just in a more concise notation?
>>
> >From http://doc.qt.io/qt-5/qtquick-performance.html#javascript-code
>
> "There are two types of bindings in QML: optimized and non-optimized
> bindings.
> ...
> Things to avoid in binding expressions to maximize optimizability:
> ...
> * constructing closures or defining functions within the binding expression"
>
> If I understand that correctly, adding {} already breaks some optimizations.
>
>

I think "{}" is a way of making scope explicit, not defining a closure
nor an internal function.

But thanks for the link. Bookmarked it. And as I said in a previous
comment, I made the change anyway as it does make the code cleaner

PS Jenkins bot (ps-jenkins) wrote on 2015-11-07:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-08

2037. By Launchpad Translations on behalf of unity-team on 2015-11-07: Launchpad automatic translations update.
2038. By Launchpad Translations on behalf of unity-team on 2015-11-08: Launchpad automatic translations update.

PS Jenkins bot (ps-jenkins) wrote on 2015-11-08:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-12

2039. By Launchpad Translations on behalf of unity-team on 2015-11-11

Launchpad automatic translations update.

2040. By Michael Terry on 2015-11-12

Make a few DBus calls asynchronous, for a smoother UX.

The calls I've changed here are neither hugely important nor frequent calls. But every little bit helps.

- Made a few sync calls async.

- Made a few sync calls more obviously sync. We had several instances of asyncCall()'s return value -- a QDBusPendingReply -- being assigned to a QDBusReply variable, which makes it wait for the call to finish. In cases where it didn't make sense to rewrite logic to be async, I've merely changed the method to be call() instead of asyncCall() for clarity.

- I removed the API in our AccountsService plugin for even making sync calls. This won't stop future developers from from writing sync code, but might give them pause.

- I removed some test mocks for our AccountsService plugin interface and changed those tests to use our actual AS plugin against a mock AS server. In truth, this change was because I had a devil of a time crafting a fake reply that included a custom complex type. But it's a good change anyway. Exercises more of our code in tests and reduces duplicated interfaces.
Approved by: Albert Astals Cid

2041. By Daniel d'Andrada on 2015-11-12

Cursor: properly initialize hotspot position Fixes: #1510407
Approved by: Gerry Boland

2042. By Albert Astals Cid on 2015-11-12

Warn we're using only the cache when not connected to the interwebs

Approved by: Michael Terry

2043. By Michael Zanetti on 2015-11-12

added icon for the dash Fixes: #1488146
Approved by: Albert Astals Cid, Lukáš Tinkl

2044. By Daniel d'Andrada on 2015-11-12

Update GSettings mock in tst_OrientedShell

Gets rid of the following warning:
OrientedShell.qml:76: Error: Cannot assign to non-existent property "disableHeight"
Approved by: Albert Astals Cid

2045. By Andrea Cimitan on 2015-11-12

Add sharing widget to zoomable image and video playback
Approved by: Albert Astals Cid, Pawel Stolowski

2046. By Lukáš Tinkl on 2015-11-12

Restore windows when activating from the spread, maintain a focus stack

Stop displaying the "grabbing" icon when we merely click to focus the app's decoration.

Provide keyboard shortcuts for common window operations
Approved by: Michael Zanetti

2047. By Michael Zanetti on 2015-11-12

prevent windows to be moved under the panel

If they happen to have a saved state which is under the panel
(might happen on alt+drag later), they will be moved below the panel
on close and reopen. This is how unity7 behaves in this regard. Fixes: #1438465
Approved by: Lukáš Tinkl

2048. By Michael Zanetti on 2015-11-12

use UbuntuNumberAnimations instead of linear ones for window state transitions Fixes: #1497097
Approved by: Lukáš Tinkl

2049. By Albert Astals Cid on 2015-11-12

Make cardWidth and cardHeight real

If they are var the properties depending on them get reevaluated even if they don't change
Approved by: Michael Zanetti

2050. By Michael Zanetti on 2015-11-12

update inputinfo api to the latest upstream snapshot

* Import latest update of api from gerrit.
* drop all the old mock code
* instead of mocking the whole api, add mocks for the backend only. This should simplify future updates and moving to upstream implementation a lot.
* update tests to use new mocking system
Approved by: Lukáš Tinkl

2051. By Michael Zanetti on 2015-11-12

Add a warning dialog when disconnecting the external monitor.

In case there are still legacy apps running, the dialog forces the user to reconnect the external monitor, or close all the legacy apps.
Approved by: Daniel d'Andrada

2052. By Albert Astals Cid on 2015-11-12

Reset instead of qFatal when removing things from the middle

This can be optimized but let's see how this behaves, at least we won't qFatal anymore :D Fixes: #1238979
Approved by: Andrea Cimitan

2053. By CI Train Bot Account on 2015-11-12

Releasing 8.11+16.04.20151112.1-0ubuntu1

Daniel d'Andrada (dandrader) wrote on 2015-11-19:

Updated according to design spec.

PS Jenkins bot (ps-jenkins) wrote on 2015-11-19:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-20

2054. By CI Train Bot Account on 2015-11-20: Resync trunk.

Albert Astals Cid (aacid) wrote on 2015-11-20:

Text conflict in qml/Stages/DesktopStage.qml
Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
Text conflict in tests/qmltests/tst_Shell.qml
3 conflicts encountered.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-11-20:

> Text conflict in qml/Stages/DesktopStage.qml
> Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
> Text conflict in tests/qmltests/tst_Shell.qml
> 3 conflicts encountered.

Fixed.

Albert Astals Cid (aacid) on 2015-11-20:

review: Abstain (merges fine)

PS Jenkins bot (ps-jenkins) wrote on 2015-11-20:

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

review: Needs Fixing (continuous-integration)

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-23

2055. By Launchpad Translations on behalf of unity-team on 2015-11-21: Launchpad automatic translations update.
2056. By Launchpad Translations on behalf of unity-team on 2015-11-23: Launchpad automatic translations update.

Michael Zanetti (mzanetti) wrote on 2015-11-23:

The jenkins test failure seems a real one. also, trying to run this on my laptop I get:

file:///usr/share/unity8//OrientedShell.qml:176:5: Type Shell unavailable
         Shell {
         ^
file:///usr/share/unity8//Shell.qml:537:9: Type Launcher unavailable
             Launcher {
             ^
file:///usr/share/unity8//Launcher/Launcher.qml:211:5: Type EdgeBarrier unavailable
         EdgeBarrier {
         ^
file:///usr/share/unity8//Components/EdgeBarrier.qml:65:5: Type EdgeBarrierController unavailable
         EdgeBarrierController {
         ^
file:///usr/share/unity8//Components/EdgeBarrierController.qml: Type EdgeBarrierSettings unavailable
file:///usr/lib/x86_64-linux-gnu/unity8/qml/Utils/EdgeBarrierSettings.qml:33:23: Expected token `identifier'
         property QtObject private: QtObject {

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-11-23:

> The jenkins test failure seems a real one. also, trying to run this on my
> laptop I get:
> [...]

Fixed.

Also fixed the problem in tst_Shell.qml

Michael Zanetti (mzanetti) wrote on 2015-11-23:

I'm still not 100% satisfied with the visuals. But I understand it's a lot of fiddling to tweak that further. I'm okay with doing that in a future branch. Let's land it.

All my other review comments have been addressed, so

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

yes

* Did CI run pass? If not, please explain why.

not yet, but issue has been fixed, let's see if next run passes.

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

yes

review: Approve

PS Jenkins bot (ps-jenkins) wrote on 2015-11-23:

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

review: Needs Fixing (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2015-11-23:

I'm afraid at least some of the autopilot failures are related to the changes here. At least they passed today already on another branch (e.g. https://code.launchpad.net/~cimi/unity8/new-shadows-1.3/+merge/271611)

Can you please check them

review: Needs Information

PS Jenkins bot (ps-jenkins) wrote on 2015-11-23:

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-11-23:

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

review: Needs Fixing (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2015-11-23:

ok... seems that was a stale run above. jenkins looks ok now.

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

yes

* Did CI run pass? If not, please explain why.

on v+o it did, yes. x AP tests still busted.

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

yes

review: Approve

lp:~dandrader/unity8/mouseEdgePush updated on 2015-11-26

2057. By Daniel d'Andrada on 2015-11-24

Merge lp:~dandrader/unity8/noStretchOnResize

2058. By Daniel d'Andrada on 2015-11-24

Merge lp:~lukas-kde/unity8/newWindowDecosAndPanel

2059. By Daniel d'Andrada on 2015-11-24

Mouse has to push against edges to show launcher or apps spread

edge-barrier-sensitivity is the property that should show up in the System Settings GUI.

edge-barrier-min-push and edge-barrier-max-push are exposed in GSettings merely as a
convenience so you can tweak those values without having to restart unity8. But they
should NOT show up in system settings.

2060. By Daniel d'Andrada on 2015-11-26

Merge lp:~lukas-kde/unity8/newWindowDecosAndPanel again

Unmerged revisions

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mohammad Rakibul Hasan

Unity Team

 === modified file 'data/com.canonical.Unity8.gschema.xml'
 --- data/com.canonical.Unity8.gschema.xml	2015-08-19 21:45:40 +0000
 +++ data/com.canonical.Unity8.gschema.xml	2015-11-24 17:51:40 +0000
@@ -11,6 +11,22 @@
        <summary>The usage mode.</summary>
        <description>The usage mode chosen will affect the Window Management behaviour.</description>
      </key>
++    <key type="y" name="edge-barrier-sensitivity">
++      <default>35</default>
++      <range min="1" max="100"/>
++      <summary>Sensitivity of screen edge barriers for the mouse pointer.</summary>
++      <description>Some UI actions like revealing the launcher or the applications spread are triggered by pushing the mouse pointer against a screen edge. This key defines how much you have to push in order to trigger the associated action.</description>
++    </key>
++    <key type="u" name="edge-barrier-min-push">
++      <default>2</default>
++      <summary>Minimum push needed to overcome edge barrier</summary>
++      <description>How much you have to push  (in grid units)the mouse against an edge barrier when sensibility is 100.</description>
++    </key>
++    <key type="u" name="edge-barrier-max-push">
++      <default>60</default>
++      <summary>Maximum push needed to overcome edge barrier</summary>
++      <description>How much you have to push (in grid units) the mouse against an edge barrier when sensibility is 1.</description>
++    </key>
    </schema>
    <schema path="/com/canonical/unity8/greeter/" id="com.canonical.Unity8.Greeter" gettext-domain="unity8">
 === modified file 'plugins/Cursor/MousePointer.cpp'
 --- plugins/Cursor/MousePointer.cpp	2015-11-12 20:39:12 +0000
 +++ plugins/Cursor/MousePointer.cpp	2015-11-24 17:51:40 +0000
@@ -44,8 +44,10 @@
      qreal newX = x() + movement.x();
      if (newX < 0) {
++        Q_EMIT pushedLeftBoundary(qAbs(newX), buttons);
          newX = 0;
      } else if (newX > parentItem()->width()) {
++        Q_EMIT pushedRightBoundary(newX - parentItem()->width(), buttons);
          newX = parentItem()->width();
+     }
      setX(newX);
 === modified file 'plugins/Cursor/MousePointer.h'
 --- plugins/Cursor/MousePointer.h	2015-10-21 16:16:37 +0000
 +++ plugins/Cursor/MousePointer.h	2015-11-24 17:51:40 +0000
@@ -42,6 +42,10 @@
      void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
              Qt::KeyboardModifiers modifiers) override;
++Q_SIGNALS:
++    void pushedLeftBoundary(qreal amount, Qt::MouseButtons buttons);
++    void pushedRightBoundary(qreal amount, Qt::MouseButtons buttons);
++
  protected:
      void itemChange(ItemChange change, const ItemChangeData &value) override;
 === added file 'plugins/Utils/EdgeBarrierSettings.qml'
 --- plugins/Utils/EdgeBarrierSettings.qml	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/EdgeBarrierSettings.qml	2015-11-24 17:51:40 +0000
@@ -0,0 +1,66 @@
++/*
++ * Copyright (C) 2015 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/>.
++ */
++
++pragma Singleton
++import QtQuick 2.4
++import GSettings 1.0
++
++QtObject {
++    id: root
++
++    // The only public property
++    readonly property real pushThreshold:
++            d.minPushThreshold + ((d.maxPushThreshold - d.minPushThreshold) * (1.0 - d.sensitivity))
++
++    onPushThresholdChanged: {
++        // Avoid calling d.printSettings() directly as it would spam the console during initialization
++        d.printSettingsTimer.start();
++    }
++
++    property QtObject priv: QtObject {
++        id: d
++
++        property Timer printSettingsTimer: Timer {
++            interval: 1
++            onTriggered: printSettings();
++        }
++        function printSettings() {
++            console.log("EdgeBarrierSettings: min="+(minPushThreshold/units.gu(1))+"gu("+minPushThreshold+"px)"
++            +", max="+(maxPushThreshold/units.gu(1))+"gu("+maxPushThreshold+"px)"
++            +", sensitivity="+sensitivity
++            +", threshold="+(pushThreshold/units.gu(1))+"gu("+pushThreshold+"px)"
++            );
++        }
++
++        property real defaultMinPushThreshold: units.gu(2)
++        property real minPushThreshold: gsettings.edgeBarrierMinPush ? units.gu(gsettings.edgeBarrierMinPush) : defaultMinPushThreshold
++        property real maxPushThreshold: {
++            if (gsettings.edgeBarrierMaxPush && units.gu(gsettings.edgeBarrierMaxPush) > minPushThreshold) {
++                return units.gu(gsettings.edgeBarrierMaxPush);
++            } else if (minPushThreshold == defaultMinPushThreshold) {
++                return units.gu(60);
++            } else {
++                return minPushThreshold * 10.0;
++            }
++        }
++        // Value range is [0.0, 1.0]
++        readonly property real sensitivity: gsettings.edgeBarrierSensitivity
++            ? Math.min(Math.max(0, gsettings.edgeBarrierSensitivity), 100) / 100
++            : 0.35
++
++        property var gsettings: GSettings { schema.id: "com.canonical.Unity8" }
++    }
++}
 === modified file 'plugins/Utils/qmldir'
 --- plugins/Utils/qmldir	2014-08-14 11:43:32 +0000
 +++ plugins/Utils/qmldir	2015-11-24 17:51:40 +0000
@@ -2,3 +2,4 @@
  plugin Utils-qml
  typeinfo Utils.qmltypes
  Style 0.1 Style.js
++singleton EdgeBarrierSettings 0.1 EdgeBarrierSettings.qml
 === added file 'qml/Components/EdgeBarrier.qml'
 --- qml/Components/EdgeBarrier.qml	1970-01-01 00:00:00 +0000
 +++ qml/Components/EdgeBarrier.qml	2015-11-24 17:51:40 +0000
@@ -0,0 +1,111 @@
++/*
++ * Copyright (C) 2015 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++
++/*
++   An edge barrier for the mouse pointer
++
++   The further you push against it, the stronger the visual hint. Until it's
++   overcome, when passed() is emitted.
++ */
++Item {
++    id: root
++
++    // Supported values are: Qt.LeftEdge, Qt.RightEdge
++    property int edge: Qt.LeftEdge
++
++    property Item target: parent
++    function push(amount) { controller.push(amount); }
++    signal passed()
++
++    anchors.top: (edge == Qt.LeftEdge || edge == Qt.RightEdge) ? target.top : undefined
++    anchors.bottom: (edge == Qt.LeftEdge || edge == Qt.RightEdge) ? target.bottom : undefined
++    anchors.left: edge == Qt.LeftEdge ? target.left : undefined
++    anchors.right: edge == Qt.RightEdge ? target.right : undefined
++
++    width: units.gu(0.5)
++
++    property Component material
++
++    Loader {
++        id: materialContainer
++
++        sourceComponent: root.material
++
++        anchors.top: parent.top
++        anchors.bottom: parent.bottom
++        anchors.left: root.edge == Qt.LeftEdge ? root.left : undefined
++        anchors.right: root.edge == Qt.RightEdge ? root.right : undefined
++
++        anchors.leftMargin: root.edge == Qt.LeftEdge ? -width * (1 - positionProgress) : 0
++        anchors.rightMargin: root.edge == Qt.RightEdge ? -width * (1 - positionProgress) : 0
++
++        property real positionProgress
++
++        visible: positionProgress > 0
++
++        width: units.gu(2)
++    }
++
++    EdgeBarrierController {
++        id: controller
++        objectName: "edgeBarrierController"
++        anchors.fill: parent
++        onPassed: root.passed();
++    }
++
++    state: {
++        if (controller.progress === 0.0) {
++            return "";
++        } else if (controller.progress < 1.0) {
++            return "resisting";
++        } else { // controller.progress == 1.0
++            return "passed";
++        }
++    }
++    states: [
++        State {
++            name: ""
++            PropertyChanges { target: materialContainer; opacity: 0.0 }
++            PropertyChanges { target: materialContainer; positionProgress: 0.0 }
++        },
++        State {
++            name: "resisting"
++            PropertyChanges { target: materialContainer; opacity: controller.progress }
++            PropertyChanges { target: materialContainer; positionProgress: controller.progress }
++        },
++        State {
++            name: "passed"
++            PropertyChanges { target: materialContainer; opacity: 0.0 }
++            PropertyChanges { target: materialContainer; positionProgress: 1.0 }
++        }
++    ]
++    transitions: [
++        Transition {
++            from: "passed"; to: ""
++        },
++        Transition {
++            from: "resisting"; to: ""
++            UbuntuNumberAnimation { target: materialContainer; properties: "opacity,positionProgress" }
++        },
++        Transition {
++            from: "resisting"; to: "passed"
++            UbuntuNumberAnimation { target: materialContainer; property: "opacity" }
++        }
++    ]
++}
 === added file 'qml/Components/EdgeBarrierController.qml'
 --- qml/Components/EdgeBarrierController.qml	1970-01-01 00:00:00 +0000
 +++ qml/Components/EdgeBarrierController.qml	2015-11-24 17:51:40 +0000
@@ -0,0 +1,71 @@
++/*
++ * Copyright (C) 2015 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Utils 0.1 // For EdgeBarrierSettings
++
++MouseArea {
++    id: root
++
++    hoverEnabled: true
++
++    // Edge push progress
++    // Value range is [0.0, 1.0]
++    readonly property real progress: Math.min(Math.max(0.0, _accumulatedPush / EdgeBarrierSettings.pushThreshold), 1.0)
++
++    // Emitted when progress reaches 1.0
++    // Should trigger the action associated with this edge
++    signal passed()
++
++    function push(amount) {
++        if (!root._containsMouse) {
++            return;
++        }
++
++        if (_accumulatedPush === EdgeBarrierSettings.pushThreshold) {
++            // NO-OP
++            return;
++        }
++
++        if (_accumulatedPush + amount > EdgeBarrierSettings.pushThreshold) {
++            _accumulatedPush = EdgeBarrierSettings.pushThreshold;
++        } else {
++            _accumulatedPush += amount;
++        }
++
++        if (_accumulatedPush === EdgeBarrierSettings.pushThreshold) {
++            passed();
++        }
++    }
++
++    onEnabledChanged: {
++        if (!enabled) {
++            // reset
++            _accumulatedPush = 0;
++        }
++    }
++
++    // to be overwritten by tests
++    property bool _containsMouse: root.containsMouse
++    on_ContainsMouseChanged: {
++        if (!_containsMouse) {
++            // reset
++            _accumulatedPush = 0;
++        }
++    }
++
++    property real _accumulatedPush: 0
++}
 === modified file 'qml/Components/PanelState/PanelState.qml'
 --- qml/Components/PanelState/PanelState.qml	2015-11-09 10:16:18 +0000
 +++ qml/Components/PanelState/PanelState.qml	2015-11-24 17:51:40 +0000
@@ -22,10 +22,11 @@
      property string title: ""
      property bool buttonsVisible: false
--
--    property int panelHeight: 0
++    property bool dropShadow: false
++    property int panelHeight: units.gu(3)
      signal close()
      signal minimize()
      signal maximize()
++    signal focusMaximizedApp()
+ }
 === modified file 'qml/Components/WindowControlButtons.qml'
 --- qml/Components/WindowControlButtons.qml	2015-11-04 14:57:33 +0000
 +++ qml/Components/WindowControlButtons.qml	2015-11-24 17:51:40 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2014 Canonical, Ltd.
++ * Copyright (C) 2014-2015 Canonical, Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
@@ -12,8 +12,6 @@
+  *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-- *
-- * Authors: Michael Zanetti <michael.zanetti@canonical.com>
   */
  import QtQuick 2.4
@@ -21,43 +19,90 @@
  Row {
      id: root
--    spacing: units.gu(0.5)
++    spacing: units.gu(1)
++
++    // to be set from outside
++    property bool active: false
      signal close()
      signal minimize()
      signal maximize()
--    Rectangle {
++    MouseArea {
++        id: closeWindowButton
          objectName: "closeWindowButton"
--        height: parent.height; width: height; radius: height / 2
--        gradient: Gradient {
--            GradientStop { color: "#F49073"; position: 0 }
--            GradientStop { color: "#DF4F1C"; position: 1 }
--        }
--        border.width: units.dp(.5)
--        border.color: "black"
--        MouseArea { anchors.fill: parent; onClicked: root.close() }
++        hoverEnabled: true
++        height: parent.height
++        width: height
++        onClicked: root.close()
++
++        Rectangle {
++            anchors.centerIn: parent
++            width: units.gu(2)
++            height: units.gu(2)
++            radius: height / 2
++            color: "#ed3146"
++            visible: parent.containsMouse
++        }
++        Icon {
++            width: height
++            height: parent.height *.5
++            anchors.centerIn: parent
++            source: "graphics/window-close.svg"
++            color: root.active ? "white" : "#5d5d5d"
++            keyColor: "black"
++        }
+     }
--    Rectangle {
++
++    MouseArea {
++        id: minimizeWindowButton
          objectName: "minimizeWindowButton"
--        height: parent.height; width: height; radius: height / 2
--        gradient: Gradient {
--            GradientStop { color: "#92918C"; position: 0 }
--            GradientStop { color: "#5E5D58"; position: 1 }
--        }
--        border.width: units.dp(.5)
--        border.color: "black"
--        MouseArea { anchors.fill: parent; onClicked: root.minimize() }
++        hoverEnabled: true
++        height: parent.height
++        width: height
++        onClicked: root.minimize()
++
++        Rectangle {
++            anchors.centerIn: parent
++            width: units.gu(2)
++            height: units.gu(2)
++            radius: height / 2
++            color: "#888888"
++            visible: parent.containsMouse
++        }
++        Icon {
++            width: height
++            height: parent.height *.5
++            anchors.centerIn: parent
++            source: "graphics/window-minimize.svg"
++            color: root.active ? "white" : "#5d5d5d"
++            keyColor: "black"
++        }
+     }
--    Rectangle {
++
++    MouseArea {
++        id: maximizeWindowButton
          objectName: "maximizeWindowButton"
--        height: parent.height; width: height; radius: height / 2
--        gradient: Gradient {
--            GradientStop { color: "#92918C"; position: 0 }
--            GradientStop { color: "#5E5D58"; position: 1 }
--        }
--        border.width: units.dp(.5)
--        border.color: "black"
--        MouseArea { anchors.fill: parent; onClicked: root.maximize() }
++        hoverEnabled: true
++        height: parent.height
++        width: height
++        onClicked: root.maximize()
++
++        Rectangle {
++            anchors.centerIn: parent
++            width: units.gu(2)
++            height: units.gu(2)
++            radius: height / 2
++            color: "#888888"
++            visible: parent.containsMouse
++        }
++        Icon {
++            width: height
++            height: parent.height *.5
++            anchors.centerIn: parent
++            source: "graphics/window-maximize.svg"
++            color: root.active ? "white" : "#5d5d5d"
++            keyColor: "black"
++        }
+     }
+ }
 === added file 'qml/Components/graphics/window-close.svg'
 --- qml/Components/graphics/window-close.svg	1970-01-01 00:00:00 +0000
 +++ qml/Components/graphics/window-close.svg	2015-11-24 17:51:40 +0000
@@ -0,0 +1,14 @@
++<?xml version="1.0" encoding="iso-8859-1"?>
++<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
++<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
++<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
++	 width="94.926px" height="94.926px" viewBox="0 0 94.926 94.926" style="enable-background:new 0 0 94.926 94.926;"
++	 xml:space="preserve">
++<g>
++	<path d="M55.931,47.463L94.306,9.09c0.826-0.827,0.826-2.167,0-2.994L88.833,0.62C88.436,0.224,87.896,0,87.335,0
++		c-0.562,0-1.101,0.224-1.498,0.62L47.463,38.994L9.089,0.62c-0.795-0.795-2.202-0.794-2.995,0L0.622,6.096
++		c-0.827,0.827-0.827,2.167,0,2.994l38.374,38.373L0.622,85.836c-0.827,0.827-0.827,2.167,0,2.994l5.473,5.476
++		c0.397,0.396,0.936,0.62,1.498,0.62s1.1-0.224,1.497-0.62l38.374-38.374l38.374,38.374c0.397,0.396,0.937,0.62,1.498,0.62
++		s1.101-0.224,1.498-0.62l5.473-5.476c0.826-0.827,0.826-2.167,0-2.994L55.931,47.463z"/>
++</g>
++</svg>
 === added file 'qml/Components/graphics/window-maximize.svg'
 --- qml/Components/graphics/window-maximize.svg	1970-01-01 00:00:00 +0000
 +++ qml/Components/graphics/window-maximize.svg	2015-11-24 17:51:40 +0000
@@ -0,0 +1,12 @@
++<?xml version="1.0" encoding="iso-8859-1"?>
++<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
++<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
++<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
++	 width="459px" height="459px" viewBox="0 0 459 459" style="enable-background:new 0 0 459 459;" xml:space="preserve">
++<g>
++	<g id="check-box-outline-blank">
++		<path d="M408,51v357H51V51H408 M408,0H51C22.95,0,0,22.95,0,51v357c0,28.05,22.95,51,51,51h357c28.05,0,51-22.95,51-51V51
++			C459,22.95,436.05,0,408,0L408,0z"/>
++	</g>
++</g>
++</svg>
 === added file 'qml/Components/graphics/window-minimize.svg'
 --- qml/Components/graphics/window-minimize.svg	1970-01-01 00:00:00 +0000
 +++ qml/Components/graphics/window-minimize.svg	2015-11-24 17:51:40 +0000
@@ -0,0 +1,13 @@
++<?xml version="1.0" encoding="iso-8859-1"?>
++<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
++<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
++<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
++	 width="121.805px" height="121.804px" viewBox="0 0 121.805 121.804" style="enable-background:new 0 0 121.805 121.804;"
++	 xml:space="preserve">
++<g>
++	<g>
++		<path d="M7.308,68.211h107.188c4.037,0,7.309-3.272,7.309-7.31c0-4.037-3.271-7.309-7.309-7.309H7.308
++			C3.272,53.593,0,56.865,0,60.902C0,64.939,3.272,68.211,7.308,68.211z"/>
++	</g>
++</g>
++</svg>
 === modified file 'qml/Launcher/Launcher.qml'
 --- qml/Launcher/Launcher.qml	2015-11-04 14:57:33 +0000
 +++ qml/Launcher/Launcher.qml	2015-11-24 17:51:40 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013-2014 Canonical, Ltd.
++ * Copyright (C) 2013-2015 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
@@ -84,6 +84,12 @@
+         }
+     }
++    function pushEdge(amount) {
++        if (root.state === "") {
++            edgeBarrier.push(amount);
++        }
++    }
++
      Timer {
          id: teaseTimer
          interval: mode == "teasing" ? 200 : 300
@@ -96,7 +102,7 @@
          interval: 500
          onTriggered: {
              if (root.autohideEnabled) {
--                if (!panel.preventHiding && !hoverArea.containsMouse) {
++                if (!panel.preventHiding) {
                      root.state = ""
                  } else {
                      dismissTimer.restart()
@@ -176,7 +182,6 @@
                  root.switchToNextState("visible")
+             }
+         }
--
+     }
      MultiPointTouchArea {
@@ -203,6 +208,28 @@
          Behavior on opacity { NumberAnimation { duration: UbuntuAnimation.BriskDuration } }
+     }
++    EdgeBarrier {
++        id: edgeBarrier
++        edge: Qt.LeftEdge
++        target: parent
++        enabled: root.available
++        onPassed: { root.switchToNextState("visibleTemporary"); }
++        material: Component {
++            Item {
++                Rectangle {
++                    width: parent.height
++                    height: parent.width
++                    rotation: -90
++                    anchors.centerIn: parent
++                    gradient: Gradient {
++                        GradientStop { position: 0.0; color: panel.color}
++                        GradientStop { position: 1.0; color: Qt.rgba(panel.r,panel.g,panel.b,0)}
++                    }
++                }
++            }
++        }
++    }
++
      LauncherPanel {
          id: panel
          objectName: "launcherPanel"
@@ -248,33 +275,6 @@
+         }
+     }
--    // TODO: This should be replaced by some mechanism that reveals the launcher
--    // after a certain resistance has been overcome, like unity7 does. However,
--    // as we don't get relative mouse coordinates yet, this will do for now.
--    MouseArea {
--        id: hoverArea
--        anchors { fill: panel; rightMargin: -1 }
--        hoverEnabled: true
--        propagateComposedEvents: true
--        onContainsMouseChanged: {
--            if (containsMouse) {
--                root.switchToNextState("visibleTemporary");
--            } else {
--                dismissTimer.restart();
--            }
--        }
--        onPressed: mouse.accepted = false;
--
--        // We need to eat touch events here in order to make sure that
--        // we don't trigger both, the dragArea and the hoverArea
--        MultiPointTouchArea {
--            anchors { top: parent.top; right: parent.right; bottom: parent.bottom }
--            width: units.dp(1)
--            mouseEnabled: false
--            enabled: parent.enabled
--        }
--    }
--
      DirectionalDragArea {
          id: dragArea
          objectName: "launcherDragArea"
@@ -322,7 +322,6 @@
                  target: panel
                  x: -root.x // so we never go past panelWidth, even when teased by tutorial
+             }
--            PropertyChanges { target: hoverArea; enabled: false }
          },
          State {
              name: "visibleTemporary"
@@ -331,7 +330,6 @@
                  target: root
                  autohideEnabled: true
+             }
--            PropertyChanges { target: hoverArea; enabled: true }
          },
          State {
              name: "teasing"
 === modified file 'qml/Launcher/LauncherPanel.qml'
 --- qml/Launcher/LauncherPanel.qml	2015-11-04 14:57:13 +0000
 +++ qml/Launcher/LauncherPanel.qml	2015-11-24 17:51:40 +0000
@@ -33,6 +33,7 @@
      property bool dragging: false
      property bool moving: launcherListView.moving || launcherListView.flicking
      property bool preventHiding: moving || dndArea.draggedIndex >= 0 || quickList.state === "open" || dndArea.pressed
++                              || mouseEventEater.containsMouse || dashItem.hovered
      property int highlightIndex: -1
      signal applicationSelected(string appId)
@@ -44,6 +45,12 @@
+         }
+     }
++    MouseArea {
++        id: mouseEventEater
++        anchors.fill: parent
++        hoverEnabled: true
++    }
++
      Column {
          id: mainColumn
          anchors {
 === modified file 'qml/Panel/Handle.qml'
 --- qml/Panel/Handle.qml	2015-07-15 15:07:19 +0000
 +++ qml/Panel/Handle.qml	2015-11-24 17:51:40 +0000
@@ -19,7 +19,7 @@
  Rectangle {
      id: handle
--    color: "#333333"
++    color: "#5d5d5d"
      height: units.gu(2)
      property bool active: false
@@ -35,7 +35,7 @@
                  id: dot
                  width: units.dp(3)
                  height: width
--                color: handle.active ? "#de4814" : "#717171"
++                color: handle.active ? UbuntuColors.orange : "#717171"
                  radius: units.dp(1)
+             }
+         }
 === modified file 'qml/Panel/Indicators/client/IndicatorsClient.qml'
 --- qml/Panel/Indicators/client/IndicatorsClient.qml	2015-07-15 15:07:19 +0000
 +++ qml/Panel/Indicators/client/IndicatorsClient.qml	2015-11-24 17:51:40 +0000
@@ -22,7 +22,7 @@
  import Ubuntu.Components.ListItems 1.3 as ListItem
  Rectangle {
--    color: "black"
++    color: "#333333"
      id: root
      Component.onCompleted: {
 === modified file 'qml/Panel/IndicatorsMenu.qml'
 --- qml/Panel/IndicatorsMenu.qml	2015-09-02 07:42:27 +0000
 +++ qml/Panel/IndicatorsMenu.qml	2015-11-24 17:51:40 +0000
@@ -38,7 +38,7 @@
      property bool enableHint: true
      property bool contentEnabled: true
      property bool showOnClick: true
--    property color panelColor: "black"
++    property color panelColor: "#333333"
      signal showTapped(point position)
@@ -110,12 +110,21 @@
              height: units.gu(0.5)
              gradient: Gradient {
                  GradientStop { position: 0.0; color: "transparent" }
--                GradientStop { position: 1.0; color: "black" }
++                GradientStop { position: 1.0; color: "#333333" }
+             }
              opacity: 0.3
+         }
+     }
++    PanelSeparatorLine {
++        id: indicatorOrangeLine
++        anchors {
++            bottom: handle.top
++            left: handle.left
++            right: handle.right
++        }
++    }
++
      Rectangle {
          anchors.fill: bar
          color: panelColor
 === modified file 'qml/Panel/MenuContent.qml'
 --- qml/Panel/MenuContent.qml	2015-07-15 15:13:18 +0000
 +++ qml/Panel/MenuContent.qml	2015-11-24 17:51:40 +0000
@@ -27,7 +27,7 @@
      property QtObject indicatorsModel: null
      property int currentMenuIndex: -1
--    color: "#221e1c" // FIXME not in palette yet
++    color: "#333333" // FIXME not in palette yet
      width: units.gu(40)
      height: units.gu(42)
 === modified file 'qml/Panel/Panel.qml'
 --- qml/Panel/Panel.qml	2015-11-09 10:16:18 +0000
 +++ qml/Panel/Panel.qml	2015-11-24 17:51:40 +0000
@@ -30,23 +30,12 @@
      property real indicatorAreaShowProgress: 1.0
      property bool locked: false
--    opacity: fullscreenMode && indicators.fullyClosed ? 0.0 : 1.0
--
--    Binding {
--        target: PanelState
--        property: "panelHeight"
--        value: root.panelHeight
--    }
--
      Rectangle {
          id: darkenedArea
          property real darkenedOpacity: 0.6
          anchors {
--            top: parent.top
++            fill: parent
              topMargin: panelHeight
--            left: parent.left
--            right: parent.right
--            bottom: parent.bottom
+         }
          color: "black"
          opacity: indicators.unitProgress * darkenedOpacity
@@ -59,16 +48,18 @@
+         }
+     }
++    Binding {
++        target: PanelState
++        property: "panelHeight"
++        value: indicators.minimizedPanelHeight
++    }
++
      Item {
          id: indicatorArea
          objectName: "indicatorArea"
          anchors.fill: parent
--        Behavior on anchors.topMargin {
--            NumberAnimation { duration: UbuntuAnimation.FastDuration; easing: UbuntuAnimation.StandardEasing }
--        }
--
          transform: Translate {
              y: indicators.state === "initial"
                  ? (1.0 - indicatorAreaShowProgress) * -d.indicatorHeight
@@ -76,7 +67,7 @@
+         }
          BorderImage {
--            id: dropShadow
++            id: indicatorsDropShadow
              anchors {
                  fill: indicators
                  leftMargin: -units.gu(1)
@@ -86,9 +77,19 @@
              source: "graphics/rectangular_dropshadow.sci"
+         }
++        BorderImage {
++            id: panelDropShadow
++            anchors {
++                fill: indicatorAreaBackground
++                bottomMargin: -units.gu(1)
++            }
++            visible: PanelState.dropShadow && !callHint.visible
++            source: "graphics/rectangular_dropshadow.sci"
++        }
++
          Rectangle {
              id: indicatorAreaBackground
--            color: callHint.visible ? "green" : "black"
++            color: callHint.visible ? "green" : "#333333"
              anchors {
                  top: parent.top
                  left: parent.left
@@ -99,30 +100,6 @@
              Behavior on color { ColorAnimation { duration: UbuntuAnimation.FastDuration } }
+         }
--        PanelSeparatorLine {
--            id: orangeLine
--            anchors {
--                top: indicatorAreaBackground.bottom
--                left: parent.left
--                right: indicators.left
--            }
--            saturation: 1 - indicators.unitProgress
--
--            // Don't let input event pass trough
--            MouseArea { anchors.fill: parent }
--        }
--
--        Image {
--            anchors {
--                top: indicators.top
--                bottom: indicators.bottom
--                right: indicators.left
--                topMargin: indicatorArea.anchors.topMargin + indicators.minimizedPanelHeight
--            }
--            width: units.dp(2)
--            source: "graphics/VerticalDivider.png"
--        }
--
          MouseArea {
              anchors {
                  top: parent.top
@@ -130,7 +107,29 @@
                  right: indicators.left
+             }
              height: indicators.minimizedPanelHeight
--            onClicked: { if (callHint.visible) { callHint.showLiveCall(); } }
++            hoverEnabled: true
++            onClicked: callHint.visible ? callHint.showLiveCall() : PanelState.focusMaximizedApp()
++            onDoubleClicked: PanelState.maximize()
++
++            // WindowControlButtons inside the mouse area, otherwise QML doesn't grok nested hover events :/
++            // cf. https://bugreports.qt.io/browse/QTBUG-32909
++            WindowControlButtons {
++                id: windowControlButtons
++                objectName: "panelWindowControlButtons"
++                anchors {
++                    left: parent.left
++                    top: parent.top
++                    leftMargin: units.gu(1)
++                    topMargin: units.gu(0.5)
++                    bottomMargin: units.gu(0.5)
++                }
++                height: indicators.minimizedPanelHeight - anchors.topMargin - anchors.bottomMargin
++                visible: PanelState.buttonsVisible && parent.containsMouse && !root.locked && !callHint.visible
++                active: PanelState.buttonsVisible
++                onClose: PanelState.close()
++                onMinimize: PanelState.minimize()
++                onMaximize: PanelState.maximize()
++            }
+         }
          IndicatorsMenu {
@@ -146,7 +145,7 @@
              width: root.width - (windowControlButtons.visible ? windowControlButtons.width + titleLabel.width : 0)
              minimizedPanelHeight: units.gu(3)
              expandedPanelHeight: units.gu(7)
--            openedHeight: root.height - indicatorOrangeLine.height
++            openedHeight: root.height
              overFlowWidth: {
                  if (callHint.visible) {
@@ -163,58 +162,34 @@
                      callHint.showLiveCall();
+                 }
+             }
--
--            hideDragHandle {
--                anchors.bottomMargin: -indicatorOrangeLine.height
--            }
--        }
--
--        WindowControlButtons {
--            id: windowControlButtons
--            objectName: "panelWindowControlButtons"
--            anchors {
--                left: parent.left
--                top: parent.top
--                margins: units.gu(0.7)
--            }
--            height: indicators.minimizedPanelHeight - anchors.margins * 2
--            visible: PanelState.buttonsVisible && !root.locked
--            onClose: PanelState.close()
--            onMinimize: PanelState.minimize()
--            onMaximize: PanelState.maximize()
+         }
          Label {
              id: titleLabel
              objectName: "windowDecorationTitle"
              anchors {
--                left: windowControlButtons.right
++                left: parent.left
                  top: parent.top
--                margins: units.gu(0.7)
++                leftMargin: units.gu(1)
++                topMargin: units.gu(0.5)
++                bottomMargin: units.gu(0.5)
+             }
--            color: "#DFDBD2"
--            height: windowControlButtons.height
--            visible: windowControlButtons.visible
++            color: PanelState.buttonsVisible ? "#ffffff" : "#5d5d5d"
++            height: indicators.minimizedPanelHeight - anchors.topMargin - anchors.bottomMargin
++            visible: !windowControlButtons.visible && !root.locked && !callHint.visible
              verticalAlignment: Text.AlignVCenter
--            fontSize: "small"
--            font.bold: true
++            fontSize: "medium"
++            font.weight: Font.Normal
              text: PanelState.title
+         }
--        PanelSeparatorLine {
--            id: indicatorOrangeLine
--            anchors {
--                top: indicators.bottom
--                left: indicators.left
--                right: indicators.right
--            }
--        }
++        // TODO here would the Locally integrated menus come
          ActiveCallHint {
              id: __callHint
              anchors {
                  top: parent.top
--                left: windowControlButtons.visible ? windowControlButtons.right : parent.left
++                left: parent.left
+             }
              height: indicators.minimizedPanelHeight
              visible: active && indicators.state == "initial"
@@ -224,7 +199,7 @@
      QtObject {
          id: d
          objectName: "panelPriv"
--        readonly property real indicatorHeight: indicators.minimizedPanelHeight + indicatorOrangeLine.height
++        readonly property real indicatorHeight: indicators.minimizedPanelHeight
+     }
      states: [
@@ -234,6 +209,7 @@
              PropertyChanges {
                  target: indicatorArea;
                  anchors.topMargin: 0
++                opacity: 1;
+             }
          },
          State {
@@ -242,6 +218,7 @@
              PropertyChanges {
                  target: indicatorArea;
                  anchors.topMargin: indicators.state === "initial" ? -d.indicatorHeight : 0
++                opacity: indicators.fullyClosed ? 0.0 : 1.0
+             }
              PropertyChanges {
                  target: indicators.showDragHandle;
@@ -249,4 +226,15 @@
+             }
+         }
+     ]
++
++    transitions: [
++        Transition {
++            to: "onscreen"
++            UbuntuNumberAnimation { target: indicatorArea; properties: "anchors.topMargin,opacity" }
++        },
++        Transition {
++            to: "offscreen"
++            UbuntuNumberAnimation { target: indicatorArea; properties: "anchors.topMargin,opacity" }
++        }
++    ]
+ }
 === removed file 'qml/Panel/PanelBackground.qml'
 --- qml/Panel/PanelBackground.qml	2015-07-15 15:07:19 +0000
 +++ qml/Panel/PanelBackground.qml	1970-01-01 00:00:00 +0000
@@ -1,21 +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.4
--
--Rectangle {
--    color: "black"
--}
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2015-11-06 10:06:58 +0000
 +++ qml/Shell.qml	2015-11-24 17:51:40 +0000
@@ -663,6 +663,19 @@
          id: cursor
          visible: shell.hasMouse
          z: screenGrabber.z + 1
++
++        onPushedLeftBoundary: {
++            if (buttons === Qt.NoButton) {
++                launcher.pushEdge(amount);
++            }
++        }
++
++        onPushedRightBoundary: {
++            if (buttons === Qt.NoButton && applicationsDisplayLoader.item
++                    && applicationsDisplayLoader.item.pushRightEdge) {
++                applicationsDisplayLoader.item.pushRightEdge(amount);
++            }
++        }
+     }
      Rectangle {
 === modified file 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2015-10-26 09:59:50 +0000
 +++ qml/Stages/ApplicationWindow.qml	2015-11-24 17:51:40 +0000
@@ -34,6 +34,8 @@
      property QtObject application
      property int surfaceOrientationAngle
      property alias resizeSurface: sessionContainer.resizeSurface
++    property int requestedWidth: -1
++    property int requestedHeight: -1
      QtObject {
          id: d
@@ -54,7 +56,7 @@
          // Whether the Application had a surface before but lost it.
          property bool hadSurface: sessionContainer.surfaceContainer.hadSurface
--        property bool needToTakeScreenshot:
++        readonly property bool needToTakeScreenshot:
              ((sessionContainer.surface && d.surfaceInitialized) || d.hadSurface)
              && screenshotImage.status === Image.Null
              && d.applicationState === ApplicationInfoInterface.Stopped
@@ -69,7 +71,7 @@
          // Remove this when possible
          property bool surfaceInitialized: false
--        property bool supportsSurfaceResize:
++        readonly property bool supportsSurfaceResize:
                  application &&
                  ((application.supportedOrientations & Qt.PortraitOrientation)
                    || (application.supportedOrientations & Qt.InvertedPortraitOrientation))
@@ -135,7 +137,9 @@
          id: sessionContainer
          // A fake application might not even have a session property.
          session: application && application.session ? application.session : null
--        anchors.fill: parent
++
++        requestedWidth: root.requestedWidth
++        requestedHeight: root.requestedHeight
          surfaceOrientationAngle: application && application.rotatesWindowContents ? root.surfaceOrientationAngle : 0
@@ -150,6 +154,28 @@
          focus: true
+     }
++    // SessionContainer size drives ApplicationWindow size
++    Binding {
++        target: root; property: "width"
++        value: stateGroup.state === "surface" ? sessionContainer.width : root.requestedWidth
++        when: root.requestedWidth >= 0
++    }
++    Binding {
++        target: root; property: "height"
++        value: stateGroup.state === "surface" ? sessionContainer.height : root.requestedHeight
++        when: root.requestedHeight >= 0
++    }
++
++    // ApplicationWindow size drives SessionContainer size
++    Binding {
++        target: sessionContainer; property: "width"; value: root.width
++        when: root.requestedWidth < 0
++    }
++    Binding {
++        target: sessionContainer; property: "height"; value: root.height
++        when: root.requestedHeight < 0
++    }
++
      StateGroup {
          id: stateGroup
          objectName: "applicationWindowStateGroup"
 === modified file 'qml/Stages/DecoratedWindow.qml'
 --- qml/Stages/DecoratedWindow.qml	2015-11-06 13:48:29 +0000
 +++ qml/Stages/DecoratedWindow.qml	2015-11-24 17:51:40 +0000
@@ -23,29 +23,27 @@
  FocusScope {
      id: root
++    width: applicationWindow.width
++    height: (decorationShown ? decoration.height : 0) + applicationWindow.height
++
      property alias window: applicationWindow
      property alias application: applicationWindow.application
      property alias active: decoration.active
      property alias title: decoration.title
++    property alias fullscreen: applicationWindow.fullscreen
--    property bool decorationShown: true
++    readonly property bool decorationShown: !fullscreen
      property bool highlightShown: false
      property real shadowOpacity: 1
++    property alias requestedWidth: applicationWindow.requestedWidth
++    property real requestedHeight
++
      signal close()
      signal maximize()
      signal minimize()
      signal decorationPressed()
--    BorderImage {
--        anchors {
--            fill: root
--            margins: -units.gu(2)
--        }
--        source: "graphics/dropshadow2gu.sci"
--        opacity: root.shadowOpacity * .3
--    }
--
      Rectangle {
          id: selectionHighlight
          anchors.fill: parent
@@ -58,7 +56,17 @@
          anchors { left: selectionHighlight.left; right: selectionHighlight.right; bottom: selectionHighlight.bottom; }
          height: units.dp(2)
          color: UbuntuColors.orange
--        visible: root.highlightShown
++        visible: highlightShown
++    }
++
++    BorderImage {
++        anchors {
++            fill: root
++            margins: active ? -units.gu(2) : -units.gu(1.5)
++        }
++        source: "graphics/dropshadow2gu.sci"
++        opacity: root.shadowOpacity * .3
++        enabled: !fullscreen
+     }
      WindowDecoration {
@@ -68,12 +76,13 @@
          anchors { left: parent.left; top: parent.top; right: parent.right }
          height: units.gu(3)
          width: root.width
--        title: window.title !== "" ? window.title : ""
++        title: window.title
++        visible: root.decorationShown
++
          onClose: root.close();
--        onMaximize: root.maximize();
++        onMaximize: { root.decorationPressed(); root.maximize(); }
          onMinimize: root.minimize();
          onPressed: root.decorationPressed();
--        visible: decorationShown
+     }
      ApplicationWindow {
@@ -82,8 +91,7 @@
          anchors.top: parent.top
          anchors.topMargin: decoration.height
          anchors.left: parent.left
--        width: root.width
--        height: root.height - decoration.height
++        requestedHeight: root.requestedHeight - (root.decorationShown ? decoration.height : 0)
          interactive: true
          focus: true
+     }
 === modified file 'qml/Stages/DesktopSpread.qml'
 --- qml/Stages/DesktopSpread.qml	2015-11-06 13:48:29 +0000
 +++ qml/Stages/DesktopSpread.qml	2015-11-24 17:51:40 +0000
@@ -28,6 +28,11 @@
      readonly property alias highlightedIndex: spreadRepeater.highlightedIndex
++    function show() {
++        spreadContainer.animateIn = true;
++        root.state = "altTab";
++    }
++
      onFocusChanged: {
          // When the spread comes active, we want to keep focus to the input handler below
          // Make sure nothing inside the ApplicationWindow grabs our focus!
@@ -515,23 +520,4 @@
+         }
+     ]
--
--    MouseArea {
--        id: rightEdgePushArea
--        anchors {
--            top: parent.top
--            right: parent.right
--            bottom: parent.bottom
--        }
--        // TODO: Make this a push to edge thing like the launcher when we can,
--        // for now, yes, we want 1 pixel, regardless of the scaling
--        width: 1
--        hoverEnabled: true
--        onContainsMouseChanged: {
--            if (containsMouse) {
--                spreadContainer.animateIn = true;
--                root.state = "altTab";
--            }
--        }
--    }
+ }
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2015-11-12 20:40:49 +0000
 +++ qml/Stages/DesktopStage.qml	2015-11-24 17:51:40 +0000
@@ -12,12 +12,9 @@
+  *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
-- *
-- * Authors: Michael Zanetti <michael.zanetti@canonical.com>
   */
  import QtQuick 2.4
--import QtQuick.Layouts 1.1
  import Ubuntu.Components 1.3
  import Unity.Application 0.1
  import "../Components/PanelState"
@@ -33,6 +30,11 @@
      // functions to be called from outside
      function updateFocusedAppOrientation() { /* TODO */ }
      function updateFocusedAppOrientationAnimated() { /* TODO */}
++    function pushRightEdge(amount) {
++        if (spread.state === "") {
++            edgeBarrier.push(amount);
++        }
++    }
      mainApp: ApplicationManager.focusedApplicationId
              ? ApplicationManager.findApplication(ApplicationManager.focusedApplicationId)
@@ -55,7 +57,7 @@
          onFocusRequested: {
              var appIndex = priv.indexOf(appId);
              var appDelegate = appRepeater.itemAt(appIndex);
--            appDelegate.restoreFromMinimized();
++            appDelegate.restore();
              if (spread.state == "altTab") {
                  spread.cancel();
@@ -107,7 +109,7 @@
          id: minimizeRestoreShortcut
          shortcut: Qt.MetaModifier|Qt.ControlModifier|Qt.Key_Down
          onTriggered: priv.focusedAppDelegate.maximized || priv.focusedAppDelegate.maximizedLeft || priv.focusedAppDelegate.maximizedRight
--                     ? priv.focusedAppDelegate.restore() : priv.focusedAppDelegate.minimize(true)
++                     ? priv.focusedAppDelegate.restoreFromMaximized() : priv.focusedAppDelegate.minimize()
          active: priv.focusedAppDelegate !== null
+     }
@@ -119,18 +121,16 @@
              var index = indexOf(focusedAppId);
              return index >= 0 && index < appRepeater.count ? appRepeater.itemAt(index) : null
+         }
++        onFocusedAppDelegateChanged: updateForegroundMaximizedApp();
++
          property int foregroundMaximizedAppIdIndex: -1
          function updateForegroundMaximizedApp() {
              for (var i = 0; i < appRepeater.count; i++) {
                  var item = appRepeater.itemAt(i);
--
                  if (item && item.visuallyMaximized) {
--                    var app = ApplicationManager.get(i);
--                    if (app) {
--                        foregroundMaximizedAppIdIndex = i;
--                        return;
--                    }
++                    foregroundMaximizedAppIdIndex = i;
++                    return;
+                 }
+             }
              foregroundMaximizedAppIdIndex = -1;
@@ -149,7 +149,7 @@
              for (var i = 0; i < appRepeater.count; i++) {
                  var appDelegate = appRepeater.itemAt(i);
                  if (appDelegate && !appDelegate.minimized) {
--                    appDelegate.minimize(false); // minimize but don't switch focus
++                    appDelegate.minimize();
+                 }
+             }
@@ -173,24 +173,47 @@
          onClose: {
              ApplicationManager.stopApplication(ApplicationManager.focusedApplicationId)
+         }
--        onMinimize: appRepeater.itemAt(0).minimize(true);
--        onMaximize: appRepeater.itemAt(0).restore();
++        onMinimize: priv.focusedAppDelegate && priv.focusedAppDelegate.minimize();
++        onMaximize: priv.focusedAppDelegate // don't restore minimized apps when double clicking the panel
++                    && priv.focusedAppDelegate.restoreFromMaximized();
++        onFocusMaximizedApp: if (priv.foregroundMaximizedAppIdIndex != -1) {
++                                 ApplicationManager.focusApplication(appRepeater.itemAt(priv.foregroundMaximizedAppIdIndex).appId);
++                             }
+     }
      Binding {
          target: PanelState
          property: "buttonsVisible"
--        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized
++        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus
++               && spread.state == ""
+     }
      Binding {
          target: PanelState
          property: "title"
--        value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.title
--        when: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized
--    }
--
--    Component.onDestruction: PanelState.buttonsVisible = false;
++        value: {
++            if (priv.focusedAppDelegate !== null && spread.state == "") {
++                if (priv.focusedAppDelegate.maximized)
++                    return priv.focusedAppDelegate.title
++                else
++                    return priv.focusedAppDelegate.appName
++            }
++            return ""
++        }
++        when: priv.focusedAppDelegate
++    }
++
++    Binding {
++        target: PanelState
++        property: "dropShadow"
++        value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppIdIndex !== -1
++    }
++
++    Component.onDestruction: {
++        PanelState.title = "";
++        PanelState.buttonsVisible = false;
++        PanelState.dropShadow = false;
++    }
      FocusScope {
          id: appContainer
@@ -211,17 +234,16 @@
              model: ApplicationManager
              objectName: "appRepeater"
--            onItemAdded: priv.updateForegroundMaximizedApp()
--            onItemRemoved: priv.updateForegroundMaximizedApp()
--
              delegate: FocusScope {
                  id: appDelegate
                  objectName: "appDelegate_" + appId
                  z: ApplicationManager.count - index
--                y: units.gu(3)
--                width: units.gu(60)
--                height: units.gu(50)
++                y: PanelState.panelHeight
                  focus: appId === priv.focusedAppId
++                width: decoratedWindow.width
++                height: decoratedWindow.height
++                property alias requestedWidth: decoratedWindow.requestedWidth
++                property alias requestedHeight: decoratedWindow.requestedHeight
                  QtObject {
                      id: appDelegatePrivate
@@ -238,6 +260,7 @@
                  readonly property string appId: model.appId
                  property bool animationsEnabled: true
                  property alias title: decoratedWindow.title
++                readonly property string appName: model.name
                  property bool visuallyMaximized: false
                  property bool visuallyMinimized: false
@@ -247,7 +270,6 @@
+                     }
+                 }
--                onZChanged: priv.updateForegroundMaximizedApp()
                  onVisuallyMaximizedChanged: priv.updateForegroundMaximizedApp()
                  visible: !visuallyMinimized &&
@@ -287,19 +309,18 @@
+                 }
                  function minimize(animated) {
                      animationsEnabled = (animated === undefined) || animated;
--                    appDelegatePrivate.maximized = false;
                      appDelegatePrivate.minimized = true;
+                 }
++                function restoreFromMaximized(animated) {
++                    animationsEnabled = (animated === undefined) || animated;
++                    appDelegatePrivate.minimized = false;
++                    appDelegatePrivate.maximized = false;
++                    appDelegatePrivate.maximizedLeft = false;
++                    appDelegatePrivate.maximizedRight = false;
++                }
                  function restore(animated) {
                      animationsEnabled = (animated === undefined) || animated;
                      appDelegatePrivate.minimized = false;
--                    appDelegatePrivate.maximized = false;
--                    appDelegatePrivate.maximizedLeft = false;
--                    appDelegatePrivate.maximizedRight = false;
--                }
--                function restoreFromMinimized(animated) {
--                    animationsEnabled = (animated === undefined) || animated;
--                    appDelegatePrivate.minimized = false;
                      if (maximized)
                          maximize();
                      else if (maximizedLeft)
@@ -311,6 +332,14 @@
                  states: [
                      State {
++                        name: "fullscreen"; when: decoratedWindow.fullscreen
++                        extend: "maximized"
++                        PropertyChanges {
++                            target: appDelegate;
++                            y: -PanelState.panelHeight
++                        }
++                    },
++                    State {
                          name: "normal";
                          when: !appDelegate.maximized && !appDelegate.minimized
                                && !appDelegate.maximizedLeft && !appDelegate.maximizedRight
@@ -321,22 +350,24 @@
+                         }
                      },
                      State {
--                        name: "maximized"; when: appDelegate.maximized
++                        name: "maximized"; when: appDelegate.maximized && !appDelegate.minimized
                          PropertyChanges {
                              target: appDelegate;
                              x: 0; y: 0;
--                            width: root.width; height: root.height;
++                            requestedWidth: root.width; requestedHeight: root.height;
                              visuallyMinimized: false;
                              visuallyMaximized: true
+                         }
                      },
                      State {
                          name: "maximizedLeft"; when: appDelegate.maximizedLeft && !appDelegate.minimized
--                        PropertyChanges { target: appDelegate; x: 0; y: units.gu(3); width: root.width/2; height: root.height - units.gu(3) }
++                        PropertyChanges { target: appDelegate; x: 0; y: PanelState.panelHeight;
++                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
                      },
                      State {
                          name: "maximizedRight"; when: appDelegate.maximizedRight && !appDelegate.minimized
--                        PropertyChanges { target: appDelegate; x: root.width/2; y: units.gu(3); width: root.width/2; height: root.height - units.gu(3) }
++                        PropertyChanges { target: appDelegate; x: root.width/2; y: PanelState.panelHeight;
++                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
                      },
                      State {
                          name: "minimized"; when: appDelegate.minimized
@@ -355,32 +386,32 @@
                          to: "normal"
                          enabled: appDelegate.animationsEnabled
                          PropertyAction { target: appDelegate; properties: "visuallyMinimized,visuallyMaximized" }
--                        UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale"; duration: UbuntuAnimation.FastDuration }
--                    },
--                    Transition {
--                        to: "maximized"
--                        enabled: appDelegate.animationsEnabled
--                        PropertyAction { target: appDelegate; property: "visuallyMinimized" }
--                        SequentialAnimation {
--                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale"; duration: UbuntuAnimation.FastDuration }
--                            PropertyAction { target: appDelegate; property: "visuallyMaximized" }
--                        }
++                        UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,requestedWidth,requestedHeight,scale"; duration: UbuntuAnimation.FastDuration }
                      },
                      Transition {
                          to: "minimized"
                          enabled: appDelegate.animationsEnabled
                          PropertyAction { target: appDelegate; property: "visuallyMaximized" }
                          SequentialAnimation {
--                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale"; duration: UbuntuAnimation.FastDuration }
++                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,requestedWidth,requestedHeight,scale"; duration: UbuntuAnimation.FastDuration }
                              PropertyAction { target: appDelegate; property: "visuallyMinimized" }
                              ScriptAction {
                                  script: {
--                                    if (appDelegate.animationsEnabled && state === "minimized" ) {
++                                    if (appDelegate.minimized) {
                                          priv.focusNext();
+                                     }
+                                 }
+                             }
+                         }
++                    },
++                    Transition {
++                        to: "*" //maximized and fullscreen
++                        enabled: appDelegate.animationsEnabled
++                        PropertyAction { target: appDelegate; property: "visuallyMinimized" }
++                        SequentialAnimation {
++                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,requestedWidth,requestedHeight,scale"; duration: UbuntuAnimation.FastDuration }
++                            PropertyAction { target: appDelegate; property: "visuallyMaximized" }
++                        }
+                     }
+                 ]
@@ -410,16 +441,14 @@
                      objectName: "decoratedWindow"
                      anchors.left: appDelegate.left
                      anchors.top: appDelegate.top
--                    width: appDelegate.width
--                    height: appDelegate.height
                      application: ApplicationManager.get(index)
                      active: ApplicationManager.focusedApplicationId === model.appId
                      focus: true
                      onClose: ApplicationManager.stopApplication(model.appId)
                      onMaximize: appDelegate.maximized || appDelegate.maximizedLeft || appDelegate.maximizedRight
--                                ? appDelegate.restore() : appDelegate.maximize()
--                    onMinimize: appDelegate.minimize(true)
++                                ? appDelegate.restoreFromMaximized() : appDelegate.maximize()
++                    onMinimize: appDelegate.minimize()
                      onDecorationPressed: { ApplicationManager.focusApplication(model.appId) }
+                 }
+             }
@@ -447,6 +476,29 @@
          enabled: visible
+     }
++    EdgeBarrier {
++        id: edgeBarrier
++
++        // NB: it does its own positioning according to the specified edge
++        edge: Qt.RightEdge
++
++        onPassed: { spread.show(); }
++        material: Component {
++            Item {
++                Rectangle {
++                    width: parent.height
++                    height: parent.width
++                    rotation: 90
++                    anchors.centerIn: parent
++                    gradient: Gradient {
++                        GradientStop { position: 0.0; color: Qt.rgba(0.16,0.16,0.16,0.7)}
++                        GradientStop { position: 1.0; color: Qt.rgba(0.16,0.16,0.16,0)}
++                    }
++                }
++            }
++        }
++    }
++
      DesktopSpread {
          id: spread
          objectName: "spread"
 === modified file 'qml/Stages/SessionContainer.qml'
 --- qml/Stages/SessionContainer.qml	2015-09-29 12:28:10 +0000
 +++ qml/Stages/SessionContainer.qml	2015-11-24 17:51:40 +0000
@@ -29,13 +29,37 @@
      property alias surfaceOrientationAngle: _surfaceContainer.surfaceOrientationAngle
      property alias resizeSurface: _surfaceContainer.resizeSurface
++    property int requestedWidth: -1
++    property int requestedHeight: -1
++
      readonly property alias surfaceContainer: _surfaceContainer
      SurfaceContainer {
          id: _surfaceContainer
--        anchors.fill: parent
++        requestedWidth: root.requestedWidth
++        requestedHeight: root.requestedHeight
          surface: session ? session.surface : null
+     }
++    // SurfaceContainer size drives SessionContainer size
++    Binding {
++        target: root; property: "width"; value: _surfaceContainer.width
++        when: root.requestedWidth >= 0
++    }
++    Binding {
++        target: root; property: "height"; value: _surfaceContainer.height
++        when: root.requestedHeight >= 0
++    }
++
++    // SessionContainer size drives SurfaceContainer size
++    Binding {
++        target: _surfaceContainer; property: "width"; value: root.width
++        when: root.requestedWidth < 0
++    }
++    Binding {
++        target: _surfaceContainer; property: "height"; value: root.height
++        when: root.requestedHeight < 0
++    }
++
      Repeater {
          id: childSessionsRepeater
          model: root.childSessions
 === modified file 'qml/Stages/SurfaceContainer.qml'
 --- qml/Stages/SurfaceContainer.qml	2015-10-26 09:59:50 +0000
 +++ qml/Stages/SurfaceContainer.qml	2015-11-24 17:51:40 +0000
@@ -31,6 +31,9 @@
      property string name: surface ? surface.name : ""
      property bool resizeSurface: true
++    property int requestedWidth: -1
++    property int requestedHeight: -1
++
      onSurfaceChanged: {
          if (surface) {
              surfaceItem.surface = surface;
@@ -54,16 +57,65 @@
          consumesInput: true
--        surfaceWidth: root.resizeSurface ? width : -1
--        surfaceHeight: root.resizeSurface ? height : -1
--
--        anchors.fill: root
++        surfaceWidth: {
++            if (root.resizeSurface) {
++                if (root.requestedWidth >= 0) {
++                    return root.requestedWidth;
++                } else {
++                    return width;
++                }
++            } else {
++                return -1;
++            }
++        }
++
++        surfaceHeight: {
++            if (root.resizeSurface) {
++                if (root.requestedHeight >= 0) {
++                    return root.requestedHeight;
++                } else {
++                    return height;
++                }
++            } else {
++                return -1;
++            }
++        }
++
          enabled: root.interactive
          focus: true
          antialiasing: !root.interactive
          orientationAngle: root.surfaceOrientationAngle
+     }
++    // MirSurface size drives SurfaceContainer size
++    Binding {
++        target: surfaceItem; property: "width"; value: root.surface ? root.surface.size.width : 0
++        when: root.requestedWidth >= 0 && root.surface
++    }
++    Binding {
++        target: surfaceItem; property: "height"; value: root.surface ? root.surface.size.height : 0
++        when: root.requestedHeight >= 0 && root.surface
++    }
++    Binding {
++        target: root; property: "width"; value: surfaceItem.width
++        when: root.requestedWidth >= 0
++    }
++    Binding {
++        target: root; property: "height"; value: surfaceItem.height
++        when: root.requestedHeight >= 0
++    }
++
++    // SurfaceContainer size drives MirSurface size
++    Binding {
++        target: surfaceItem; property: "width"; value: root.width
++        when: root.requestedWidth < 0
++    }
++    Binding {
++        target: surfaceItem; property: "height"; value: root.height
++        when: root.requestedHeight < 0
++    }
++
++
      TouchGate {
          targetItem: surfaceItem
          anchors.fill: root
 === modified file 'qml/Stages/WindowDecoration.qml'
 --- qml/Stages/WindowDecoration.qml	2015-11-09 10:16:18 +0000
 +++ qml/Stages/WindowDecoration.qml	2015-11-24 17:51:40 +0000
@@ -33,6 +33,8 @@
      signal minimize()
      signal maximize()
++    onDoubleClicked: root.maximize()
++
      QtObject {
          id: priv
          property real distanceX
@@ -65,20 +67,23 @@
          anchors.fill: parent
          anchors.bottomMargin: -radius
          radius: units.gu(.5)
--        gradient: Gradient {
--            GradientStop { color: "#626055"; position: 0 }
--            GradientStop { color: "#3C3B37"; position: 1 }
--        }
++        color: "#333333"
+     }
      Row {
--        anchors { fill: parent; margins: units.gu(0.7) }
--        spacing: units.gu(1)
--        opacity: root.active ? 1 : 0.5
++        anchors {
++            fill: parent
++            leftMargin: units.gu(1)
++            rightMargin: units.gu(1)
++            topMargin: units.gu(0.5)
++            bottomMargin: units.gu(0.5)
++        }
++        spacing: units.gu(3)
          WindowControlButtons {
              id: buttons
              height: parent.height
++            active: root.active
              onClose: root.close();
              onMinimize: root.minimize();
              onMaximize: root.maximize();
@@ -87,12 +92,12 @@
          Label {
              id: titleLabel
              objectName: "windowDecorationTitle"
--            color: "#DFDBD2"
++            color: root.active ? "white" : "#5d5d5d"
              height: parent.height
              width: parent.width - buttons.width - parent.anchors.rightMargin - parent.anchors.leftMargin
              verticalAlignment: Text.AlignVCenter
--            fontSize: "small"
--            font.bold: true
++            fontSize: "medium"
++            font.weight: root.active ? Font.Light : Font.Normal
              elide: Text.ElideRight
+         }
+     }
 === modified file 'qml/Stages/WindowResizeArea.qml'
 --- qml/Stages/WindowResizeArea.qml	2015-11-09 10:52:53 +0000
 +++ qml/Stages/WindowResizeArea.qml	2015-11-24 17:51:40 +0000
@@ -25,7 +25,7 @@
      anchors.fill: target
      anchors.margins: -borderThickness
--    hoverEnabled: true
++    hoverEnabled: target && !target.maximized // don't grab the resize under the panel
      property var windowStateStorage: WindowStateStorage
@@ -36,6 +36,8 @@
      property int borderThickness: 0
      property int minWidth: 0
      property int minHeight: 0
++    property int defaultWidth: units.gu(60)
++    property int defaultHeight: units.gu(50)
      property int screenWidth: 0
      property int screenHeight: 0
@@ -67,13 +69,14 @@
+     }
      Component.onCompleted: {
--        var windowGeometry = windowStateStorage.getGeometry(root.windowId, Qt.rect(target.x, target.y, target.width, target.height))
--        if (windowGeometry !== undefined) {
--            target.width = Math.min(windowGeometry.width, root.screenWidth)
--            target.height = Math.min(windowGeometry.height, root.screenHeight - PanelState.panelHeight)
--            target.x = Math.max(Math.min(windowGeometry.x, root.screenWidth - target.width), 0)
--            target.y = Math.max(Math.min(windowGeometry.y, root.screenHeight - target.height), PanelState.panelHeight)
--        }
++        var windowGeometry = windowStateStorage.getGeometry(root.windowId,
++                                                            Qt.rect(target.x, target.y, defaultWidth, defaultHeight));
++
++        target.requestedWidth = Math.min(Math.max(windowGeometry.width, minWidth), screenWidth);
++        target.requestedHeight = Math.min(Math.max(windowGeometry.height, minHeight), root.screenHeight - PanelState.panelHeight);
++        target.x = Math.max(Math.min(windowGeometry.x, root.screenWidth - target.requestedWidth), 0)
++        target.y = Math.max(Math.min(windowGeometry.y, root.screenHeight - target.requestedHeight), PanelState.panelHeight)
++
          var windowState = windowStateStorage.getState(root.windowId, WindowStateStorage.WindowStateNormal)
          if (windowState === WindowStateStorage.WindowStateMaximized) {
              target.maximize(false)
@@ -93,6 +96,18 @@
          property bool topBorder: false
          property bool bottomBorder: false
++        // true  - A change in surface size will cause the left border of the window to move accordingly.
++        //         The window's right border will stay in the same position.
++        // false - a change in surface size will cause the right border of the window to move accordingly.
++        //         The window's left border will stay in the same position.
++        property bool moveLeftBorder: false
++
++        // true  - A change in surface size will cause the top border of the window to move accordingly.
++        //         The window's bottom border will stay in the same position.
++        // false - a change in surface size will cause the bottom border of the window to move accordingly.
++        //         The window's top border will stay in the same position.
++        property bool moveTopBorder: false
++
          property bool dragging: false
          property real startMousePosX
          property real startMousePosY
@@ -100,6 +115,8 @@
          property real startY
          property real startWidth
          property real startHeight
++        property real currentWidth
++        property real currentHeight
          property string cursorName: {
              if (root.containsMouse || root.pressed) {
@@ -138,11 +155,24 @@
+         }
+     }
++    Timer {
++        id: resetBordersToMoveTimer
++        interval: 2000
++        onTriggered: {
++            d.moveLeftBorder = false;
++            d.moveTopBorder = false;
++        }
++    }
++
      onPressedChanged: {
          var pos = mapToItem(target.parent, mouseX, mouseY);
          if (pressed) {
              d.updateBorders();
++            resetBordersToMoveTimer.stop();
++            d.moveLeftBorder = d.leftBorder;
++            d.moveTopBorder = d.topBorder;
++
              var pos = mapToItem(root.target.parent, mouseX, mouseY);
              d.startMousePosX = pos.x;
              d.startMousePosY = pos.y;
@@ -150,8 +180,11 @@
              d.startY = target.y;
              d.startWidth = target.width;
              d.startHeight = target.height;
++            d.currentWidth = target.width;
++            d.currentHeight = target.height;
              d.dragging = true;
          } else {
++            resetBordersToMoveTimer.start();
              d.dragging = false;
              if (containsMouse) {
                  d.updateBorders();
@@ -182,37 +215,49 @@
          if (d.leftBorder) {
              var newTargetX = d.startX + deltaX;
              if (target.x + target.width > newTargetX + minWidth) {
--                target.width = target.x + target.width - newTargetX;
--                target.x = newTargetX;
++                target.requestedWidth = target.x + target.width - newTargetX;
              } else {
--                target.x = target.x + target.width - minWidth;
--                target.width = minWidth;
++                target.requestedWidth = minWidth;
+             }
          } else if (d.rightBorder) {
              if (d.startWidth + deltaX >= minWidth) {
--                target.width = d.startWidth + deltaX;
++                target.requestedWidth = d.startWidth + deltaX;
              } else {
--                target.width = minWidth;
++                target.requestedWidth = minWidth;
+             }
+         }
          if (d.topBorder) {
              var newTargetY = d.startY + deltaY;
              if (target.y + target.height > newTargetY + minHeight) {
--                target.height = target.y + target.height - newTargetY;
--                target.y = newTargetY;
++                target.requestedHeight = target.y + target.height - newTargetY;
              } else {
--                target.y = target.y + target.height - minHeight;
--                target.height = minHeight;
++                target.requestedHeight = minHeight;
+             }
          } else if (d.bottomBorder) {
              if (d.startHeight + deltaY >= minHeight) {
--                target.height = d.startHeight + deltaY;
++                target.requestedHeight = d.startHeight + deltaY;
              } else {
--                target.height = minHeight;
--            }
++                target.requestedHeight = minHeight;
++            }
++        }
++    }
++
++    Connections {
++        target: root.target
++        onWidthChanged: {
++            if (d.moveLeftBorder) {
++                target.x += d.currentWidth - target.width;
++            }
++            d.currentWidth = target.width;
++        }
++        onHeightChanged: {
++            if (d.moveTopBorder) {
++                target.y += d.currentHeight - target.height;
++            }
++            d.currentHeight = target.height;
+         }
+     }
+ }
 === modified file 'tests/mocks/Cursor/Cursor.qml'
 --- tests/mocks/Cursor/Cursor.qml	2015-09-29 13:45:05 +0000
 +++ tests/mocks/Cursor/Cursor.qml	2015-11-24 17:51:40 +0000
@@ -17,4 +17,6 @@
  import QtQuick 2.4
  Item {
++    signal pushedLeftBoundary(real amount, int buttons)
++    signal pushedRightBoundary(real amount, int buttons)
+ }
 === modified file 'tests/mocks/Unity/Application/MirSurface.cpp'
 --- tests/mocks/Unity/Application/MirSurface.cpp	2015-10-27 21:55:10 +0000
 +++ tests/mocks/Unity/Application/MirSurface.cpp	2015-11-24 17:51:40 +0000
@@ -35,8 +35,12 @@
      , m_activeFocus(false)
      , m_width(-1)
      , m_height(-1)
++    , m_slowToResize(false)
+ {
  //    qDebug() << "MirSurface::MirSurface() " << name;
++    m_delayedResizeTimer.setInterval(600);
++    m_delayedResizeTimer.setSingleShot(true);
++    connect(&m_delayedResizeTimer, &QTimer::timeout, this, &MirSurface::applyDelayedResize);
+ }
  MirSurface::~MirSurface()
@@ -197,7 +201,38 @@
  void MirSurface::resize(int width, int height)
+ {
++    if (m_slowToResize) {
++        if (!m_delayedResizeTimer.isActive()) {
++            m_delayedResize.setWidth(width);
++            m_delayedResize.setHeight(height);
++            m_delayedResizeTimer.start();
++        } else {
++            m_pendingResize.setWidth(width);
++            m_pendingResize.setHeight(height);
++        }
++    } else {
++        doResize(width, height);
++    }
++}
++
++void MirSurface::applyDelayedResize()
++{
++    doResize(m_delayedResize.width(), m_delayedResize.height());
++    m_delayedResize.setWidth(-1);
++    m_delayedResize.setHeight(-1);
++
++    if (m_pendingResize.isValid()) {
++        QSize size = m_pendingResize;
++        m_pendingResize.setWidth(-1);
++        m_pendingResize.setHeight(-1);
++        resize(size.width(), size.height());
++    }
++}
++
++void MirSurface::doResize(int width, int height)
++{
      bool changed = false;
++
      if (width != m_width) {
          m_width = width;
          Q_EMIT widthChanged();
@@ -214,3 +249,20 @@
          Q_EMIT sizeChanged(QSize(width, height));
+     }
+ }
++
++bool MirSurface::isSlowToResize() const
++{
++    return m_slowToResize;
++}
++
++void MirSurface::setSlowToResize(bool value)
++{
++    if (m_slowToResize != value) {
++        m_slowToResize = value;
++        Q_EMIT slowToResizeChanged();
++        if (!m_slowToResize && m_delayedResizeTimer.isActive()) {
++            m_delayedResizeTimer.stop();
++            applyDelayedResize();
++        }
++    }
++}
 === modified file 'tests/mocks/Unity/Application/MirSurface.h'
 --- tests/mocks/Unity/Application/MirSurface.h	2015-10-20 16:48:06 +0000
 +++ tests/mocks/Unity/Application/MirSurface.h	2015-11-24 17:51:40 +0000
@@ -18,6 +18,7 @@
  #define MOCK_MIR_SURFACE_H
  #include <QObject>
++#include <QTimer>
  #include <QUrl>
  #include <QHash>
@@ -33,6 +34,7 @@
      Q_PROPERTY(int width READ width NOTIFY widthChanged)
      Q_PROPERTY(int height READ height NOTIFY heightChanged)
      Q_PROPERTY(bool activeFocus READ activeFocus NOTIFY activeFocusChanged)
++    Q_PROPERTY(bool slowToResize READ isSlowToResize WRITE setSlowToResize NOTIFY slowToResizeChanged)
  public:
      MirSurface(const QString& name,
@@ -77,6 +79,9 @@
      int width() const;
      int height() const;
++    bool isSlowToResize() const;
++    void setSlowToResize(bool value);
++
      /////
      // internal mock stuff
@@ -94,13 +99,18 @@
      void orientationAngleChanged(Mir::OrientationAngle angle);
      void widthChanged();
      void heightChanged();
++    void slowToResizeChanged();
      ////
      // internal mock stuff
      void screenshotUrlChanged(QUrl);
      void activeFocusChanged(bool);
++private Q_SLOTS:
++    void applyDelayedResize();
++
  private:
++    void doResize(int width, int height);
      void updateVisibility();
      const QString m_name;
@@ -114,6 +124,12 @@
      bool m_activeFocus;
      int m_width;
      int m_height;
++
++    bool m_slowToResize;
++    QTimer m_delayedResizeTimer;
++    QSize m_delayedResize;
++    QSize m_pendingResize;
++
      struct View {
          bool visible;
      };
 === added file 'tests/mocks/Utils/EdgeBarrierSettings.qml'
 --- tests/mocks/Utils/EdgeBarrierSettings.qml	1970-01-01 00:00:00 +0000
 +++ tests/mocks/Utils/EdgeBarrierSettings.qml	2015-11-24 17:51:40 +0000
@@ -0,0 +1,22 @@
++/*
++ * Copyright (C) 2015 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/>.
++ */
++
++pragma Singleton
++import QtQuick 2.4
++
++QtObject {
++    readonly property real pushThreshold: units.gu(8)
++}
 === modified file 'tests/mocks/Utils/qmldir'
 --- tests/mocks/Utils/qmldir	2015-05-06 11:22:18 +0000
 +++ tests/mocks/Utils/qmldir	2015-11-24 17:51:40 +0000
@@ -3,3 +3,4 @@
  typeinfo Utils.qmltypes
  Style 0.1 Style.js
  HomeKeyWatcher 0.1 HomeKeyWatcher.qml
++singleton EdgeBarrierSettings 0.1 EdgeBarrierSettings.qml
 === added file 'tests/qmltests/EdgeBarrierControls.qml'
 --- tests/qmltests/EdgeBarrierControls.qml	1970-01-01 00:00:00 +0000
 +++ tests/qmltests/EdgeBarrierControls.qml	2015-11-24 17:51:40 +0000
@@ -0,0 +1,97 @@
++/*
++ * Copyright 2015 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import QtQuick.Layouts 1.1
++import Ubuntu.Components 1.3
++import Unity.Test 0.1
++
++RowLayout {
++    id: root
++    Layout.fillWidth: true
++
++    property var target: null
++    property string backgroundColor: "darkGrey"
++    property alias text: label.text
++    signal dragged(real amount);
++
++    Binding {
++        id: containsMouseBinding
++
++        // only activate the binding once the controls start to get used in order to not
++        // interfere with automated tests
++        property bool activated: false
++
++        when: root.target !== undefined && root.target !== null && activated
++        target: root.target
++        property: "_containsMouse"
++        value: checkbox.checked
++    }
++
++
++    Rectangle {
++        width: label.width + units.gu(1)
++        height: units.gu(4)
++        color: root.backgroundColor
++
++        Rectangle {
++            anchors.fill: parent
++            color: "darkGreen"
++            opacity: target ? target.progress : 0
++        }
++
++        Label {
++            id: label
++            color: "white"
++            anchors.centerIn: parent
++        }
++        MouseArea {
++            id: mouseArea
++            anchors.fill: parent
++            property real lastX
++            property bool dragging: false
++            onPressedChanged: {
++                if (pressed) {
++                    containsMouseBinding.activated = true;
++                    checkbox.checked = true;
++                } else {
++                    dragging = false;
++                }
++            }
++            onMouseXChanged: {
++                if (dragging) {
++                    var amount = Math.abs(mouseX - lastX);
++                    lastX = mouseX;
++                    root.dragged(amount);
++                } else {
++                    lastX = mouseX;
++                    dragging = true;
++                }
++            }
++        }
++    }
++
++    CheckBox {
++        id: checkbox
++        checked: false
++        activeFocusOnPress: false
++        onCheckedChanged: {
++            if (checked) {
++                containsMouseBinding.activated = true;
++            }
++        }
++    }
++}
 === modified file 'tests/qmltests/Launcher/tst_Launcher.qml'
 --- tests/qmltests/Launcher/tst_Launcher.qml	2015-10-26 09:59:50 +0000
 +++ tests/qmltests/Launcher/tst_Launcher.qml	2015-11-24 17:51:40 +0000
@@ -22,6 +22,7 @@
  import ".."
  import "../../../qml/Launcher"
  import Unity.Launcher 0.1
++import Utils 0.1 // For EdgeBarrierSettings
  /* Nothing is shown at first. If you drag from left edge you will bring up the
     launcher. */
@@ -67,6 +68,7 @@
                  Component.onCompleted: {
                      launcherLoader.itemDestroyed = false;
++                    edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");
+                 }
                  Component.onDestruction: {
                      launcherLoader.itemDestroyed = true;
@@ -82,6 +84,12 @@
          MouseTouchEmulationCheckbox {}
++        EdgeBarrierControls {
++            id: edgeBarrierControls
++            text: "Drag here to pull out launcher"
++            onDragged: { launcherLoader.item.pushEdge(amount); }
++        }
++
          Button {
              text: "emit hinting signal"
              onClicked: LauncherModel.emitHint()
@@ -207,8 +215,10 @@
              tryCompare(launcher, "state", "visible");
+         }
--        function revealByHover() {
++        function revealByEdgePush() {
++            // Place the mouse against the window/screen edge and push beyond the barrier threshold
              mouseMove(root, 1, root.height / 2);
++            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * 1.1);
              var panel = findChild(launcher, "launcherPanel");
              verify(!!panel);
@@ -278,7 +288,7 @@
          function test_clickingOnAppIconCausesSignalEmission(data) {
              if (data.mouse) {
--                revealByHover();
++                revealByEdgePush();
              } else {
                  dragLauncherIntoView();
+             }
@@ -748,12 +758,12 @@
              verify(quickList, "state", "")
+         }
--        function test_revealByHover() {
++        function test_revealByEdgePush() {
              var panel = findChild(launcher, "launcherPanel");
              verify(!!panel);
--            revealByHover();
--            tryCompare(launcher, "state", "visibleTemporary");
++            revealByEdgePush();
++            compare(launcher.state, "visibleTemporary");
              // Now move the mouse away and make sure it hides in less than a second
              mouseMove(root, root.width, root.height / 2)
 === modified file 'tests/qmltests/Panel/tst_Panel.qml'
 --- tests/qmltests/Panel/tst_Panel.qml	2015-08-03 13:48:14 +0000
 +++ tests/qmltests/Panel/tst_Panel.qml	2015-11-24 17:51:40 +0000
@@ -23,6 +23,7 @@
  import Unity.Indicators 0.1 as Indicators
  import Ubuntu.Telephony 0.1 as Telephony
  import "../../../qml/Panel"
++import "../../../qml/Components/PanelState"
  IndicatorTest {
      id: root
@@ -30,6 +31,12 @@
      height: units.gu(71)
      color: "white"
++    Binding {
++        target: mouseEmulation
++        property: "checked"
++        value: !windowControlsCB.checked
++    }
++
      RowLayout {
          anchors.fill: parent
          anchors.margins: units.gu(1)
@@ -45,17 +52,18 @@
              MouseArea {
                  id: backgroundMouseArea
                  anchors.fill: parent
--            }
--
--            Panel {
--                id: panel
--                anchors.fill: parent
--                indicators {
--                    width: parent.width > units.gu(60) ? units.gu(40) : parent.width
--                    indicatorsModel: root.indicatorsModel
++                hoverEnabled: true
++
++                Panel {
++                    id: panel
++                    anchors.fill: parent
++                    indicators {
++                        width: parent.width > units.gu(60) ? units.gu(40) : parent.width
++                        indicatorsModel: root.indicatorsModel
++                    }
++
++                    property real panelAndSeparatorHeight: panel.indicators.minimizedPanelHeight
+                 }
--
--                property real panelAndSeparatorHeight: panel.indicators.minimizedPanelHeight + units.dp(2)
+             }
+         }
@@ -93,6 +101,32 @@
+                 }
+             }
++            RowLayout {
++                Layout.fillWidth: true
++                CheckBox {
++                    id: windowControlsCB
++                    onClicked: PanelState.buttonsVisible = checked
++                }
++                Label {
++                    text: "Show window controls"
++                }
++            }
++
++            RowLayout {
++                Layout.fillWidth: true
++                CheckBox {
++                    onClicked: {
++                        if (checked)
++                            PanelState.title = "Fake window title"
++                        else
++                            PanelState.title = ""
++                    }
++                }
++                Label {
++                    text: "Show fake window title"
++                }
++            }
++
              Rectangle {
                  Layout.preferredHeight: units.dp(1);
                  Layout.fillWidth: true;
@@ -127,7 +161,7 @@
                  color: "black"
+             }
--            MouseTouchEmulationCheckbox {}
++            MouseTouchEmulationCheckbox { id: mouseEmulation }
+         }
+     }
 === modified file 'tests/qmltests/Stages/tst_DesktopStage.qml'
 --- tests/qmltests/Stages/tst_DesktopStage.qml	2015-11-06 13:48:29 +0000
 +++ tests/qmltests/Stages/tst_DesktopStage.qml	2015-11-24 17:51:40 +0000
@@ -17,11 +17,12 @@
  import QtQuick 2.4
  import QtTest 1.0
  import Ubuntu.Components 1.3
--import Ubuntu.Components.ListItems 1.3 as ListItem
++import Ubuntu.Components.ListItems 1.3
  import Unity.Application 0.1
  import Unity.Test 0.1
  import Utils 0.1
++import ".." // For EdgeBarrierControls
  import "../../../qml/Stages"
  import "../../../qml/Components"
@@ -46,8 +47,8 @@
          WindowStateStorage.geometry = {
              'unity8-dash': Qt.rect(0, units.gu(3), units.gu(50), units.gu(40)),
              'dialer-app': Qt.rect(units.gu(51), units.gu(3), units.gu(50), units.gu(40)),
--            'camera-app': Qt.rect(0, units.gu(44), units.gu(50), units.gu(40)),
--            'gallery-app': Qt.rect(units.gu(51), units.gu(44), units.gu(50), units.gu(40))
++            'gmail-webapp': Qt.rect(0, units.gu(44), units.gu(50), units.gu(40)),
++            'twitter-webapp': Qt.rect(units.gu(51), units.gu(44), units.gu(50), units.gu(40))
+         }
+     }
@@ -60,10 +61,18 @@
          focus: true
++        property bool itemDestroyed: false
          sourceComponent: Component {
              DesktopStage {
                  color: "darkblue"
                  anchors.fill: parent
++
++                Component.onCompleted: {
++                    edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");
++                }
++                Component.onDestruction: {
++                    desktopStageLoader.itemDestroyed = true;
++                }
                  orientations: Orientations {}
+             }
+         }
@@ -82,6 +91,28 @@
          Column {
              anchors { left: parent.left; right: parent.right; top: parent.top; margins: units.gu(1) }
              spacing: units.gu(1)
++
++            Button {
++                color: "white"
++                text: "Make surface slow to resize"
++                activeFocusOnPress: false
++                onClicked: {
++                    if (ApplicationManager.focusedApplicationId) {
++                        var surface = ApplicationManager.findApplication(ApplicationManager.focusedApplicationId).session.surface;
++                        surface.slowToResize = true;
++                    }
++                }
++            }
++
++            EdgeBarrierControls {
++                id: edgeBarrierControls
++                text: "Drag here to pull out spread"
++                backgroundColor: "blue"
++                onDragged: { desktopStageLoader.item.pushRightEdge(amount); }
++            }
++
++            Divider {}
++
              Repeater {
                  model: ApplicationManager.availableApplications
                  ApplicationCheckBox {
@@ -99,10 +130,16 @@
          property Item desktopStage: desktopStageLoader.status === Loader.Ready ? desktopStageLoader.item : null
          function cleanup() {
++            desktopStageLoader.itemDestroyed = false;
              desktopStageLoader.active = false;
              tryCompare(desktopStageLoader, "status", Loader.Null);
              tryCompare(desktopStageLoader, "item", null);
++            // Loader.status might be Loader.Null and Loader.item might be null but the Loader
++            // actually took place. Likely because Loader waits until the next event loop
++            // iteration to do its work. So to ensure the reload, we will wait until the
++            // Shell instance gets destroyed.
++            tryCompare(desktopStageLoader, "itemDestroyed", true);
              killAllRunningApps();
@@ -156,8 +193,8 @@
          function test_tappingOnWindowChangesFocusedApp_data() {
              return [
--                {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 0, focusTo: 1 },
--                {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 1, focusTo: 0 },
++                {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "gmail-webapp"], focusfrom: 0, focusTo: 1 },
++                {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "gmail-webapp"], focusfrom: 1, focusTo: 0 }
+             ]
+         }
@@ -203,8 +240,8 @@
          function test_tappingOnDecorationFocusesApplication_data() {
              return [
--                {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 0, focusTo: 1 },
--                {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "camera-app" ], focusfrom: 1, focusTo: 0 },
++                {tag: "dash to dialer", apps: [ "unity8-dash", "dialer-app", "gmail-webapp"], focusfrom: 0, focusTo: 1 },
++                {tag: "dialer to dash", apps: [ "unity8-dash", "dialer-app", "gmail-webapp"], focusfrom: 1, focusTo: 0 }
+             ]
+         }
@@ -214,12 +251,16 @@
              var fromAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusfrom]);
              verify(fromAppDecoration);
              tap(fromAppDecoration);
--            tryCompare(ApplicationManager.findApplication(data.apps[data.focusfrom]).session.surface, "activeFocus", true);
++            var fromApp = ApplicationManager.findApplication(data.apps[data.focusfrom]);
++            verify(fromApp);
++            tryCompare(fromApp.session.surface, "activeFocus", true);
              var toAppDecoration = findChild(desktopStage, "appWindowDecoration_" + data.apps[data.focusTo]);
              verify(toAppDecoration);
              tap(toAppDecoration);
--            tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.surface, "activeFocus", true);
++            var toApp = ApplicationManager.findApplication(data.apps[data.focusTo]);
++            verify(toApp);
++            tryCompare(toApp.session.surface, "activeFocus", true);
+         }
          function test_clickingOnDecorationFocusesApplication_data() {
@@ -339,26 +380,26 @@
          function test_maximizeApplicationHidesSurfacesBehindIt() {
              var dashApp = startApplication("unity8-dash");
              var dialerApp = startApplication("dialer-app");
--            var cameraApp = startApplication("camera-app");
++            var gmailApp = startApplication("gmail-webapp");
              var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");
              verify(dashDelegate);
              var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");
              verify(dialerDelegate);
--            var cameraDelegate = findChild(desktopStage, "appDelegate_camera-app");
--            verify(cameraDelegate);
++            var gmailDelegate = findChild(desktopStage, "appDelegate_gmail-webapp");
++            verify(gmailDelegate);
              // maximize
--            findChild(dialerDelegate, "decoratedWindow").maximize();
++            dialerDelegate.maximize();
              tryCompare(dialerDelegate, "visuallyMaximized", true);
              tryCompare(dashApp.session.surface, "visible", false);
--            compare(cameraApp.session.surface.visible, true);
++            compare(gmailApp.session.surface.visible, true);
              // restore
--            findChild(dialerDelegate, "decoratedWindow").maximize();
++            dialerDelegate.restoreFromMaximized();
              compare(dashApp.session.surface.visible, true);
--            compare(cameraApp.session.surface.visible, true);
++            compare(gmailApp.session.surface.visible, true);
+         }
          function test_applicationsBecomeVisibleWhenOccludingAppRemoved() {
@@ -370,28 +411,52 @@
              var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");
              verify(dialerDelegate);
--            var cameraApp = startApplication("camera-app");
--            var cameraDelegate = findChild(desktopStage, "appDelegate_camera-app");
--            verify(cameraDelegate);
--            findChild(dialerDelegate, "decoratedWindow").maximize();
--
--            var galleryApp = startApplication("gallery-app");
--            var galleryDelegate = findChild(desktopStage, "appDelegate_gallery-app");
--            verify(galleryDelegate);
--            findChild(galleryDelegate, "decoratedWindow").maximize();
++            var dialerMaximizeButton = findChild(dialerDelegate, "maximizeWindowButton");
++            verify(dialerMaximizeButton);
++            mouseClick(dialerMaximizeButton);
++
++            var mapApp = startApplication("map");
++            var mapDelegate = findChild(desktopStage, "appDelegate_map");
++            verify(mapDelegate);
++
++            var gmailApp = startApplication("gmail-webapp");
++            var gmailDelegate = findChild(desktopStage, "appDelegate_gmail-webapp");
++            verify(gmailDelegate);
++
++            var gmailMaximizeButton = findChild(gmailDelegate, "maximizeWindowButton");
++            verify(gmailMaximizeButton);
++            mouseClick(gmailMaximizeButton);
              tryCompare(dialerDelegate, "visuallyMaximized", true);
--            tryCompare(galleryDelegate, "visuallyMaximized", true);
++            tryCompare(gmailDelegate, "visuallyMaximized", true);
              tryCompare(dashApp.session.surface, "visible", false);
              tryCompare(dialerApp.session.surface, "visible", false);
--            tryCompare(cameraApp.session.surface, "visible", false);
--
--            ApplicationManager.stopApplication("gallery-app");
--
--            compare(cameraApp.session.surface.visible, true);
++            tryCompare(mapApp.session.surface, "visible", false);
++
++            ApplicationManager.stopApplication("gmail-webapp");
++
++            compare(mapApp.session.surface.visible, true);
              tryCompare(dialerApp.session.surface, "visible", true);
              tryCompare(dashApp.session.surface, "visible", false); // still occluded by maximised dialer
+         }
++
++        function test_maximisedAppStaysVisibleWhenAppStarts() {
++            var dashApp = startApplication("unity8-dash");
++            var dashDelegate = findChild(desktopStage, "appDelegate_unity8-dash");
++            verify(dashDelegate);
++            // maximize
++            var dashMaximizeButton = findChild(dashDelegate, "maximizeWindowButton");
++            verify(dashMaximizeButton);
++            mouseClick(dashMaximizeButton);
++            tryCompare(dashDelegate, "visuallyMaximized", true);
++
++            var dialerApp = startApplication("dialer-app");
++            var dialerDelegate = findChild(desktopStage, "appDelegate_dialer-app");
++            verify(dialerDelegate);
++
++            compare(dialerDelegate.visible, true, "Dialer should be visible");
++            compare(dashDelegate.visible, true, "Dash should still be visible");
++        }
+     }
+ }
 === modified file 'tests/qmltests/Stages/tst_WindowResizeArea.qml'
 --- tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-11-09 10:16:18 +0000
 +++ tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-11-24 17:51:40 +0000
@@ -30,8 +30,6 @@
      height: units.gu(60)
      width: units.gu(60)
--    property var fakeWindow: windowLoader.item
--
      Binding {
          target: PanelState
          property: "panelHeight"
@@ -47,10 +45,10 @@
              property alias minHeight: windowResizeArea.minHeight
              x: units.gu(20)
              y: units.gu(20)
--            height: units.gu(20)
--            width: units.gu(20)
--            property int windowHeight: height
--            property int windowWidth: width
++            width: requestedWidth
++            height: requestedHeight
++            property real requestedWidth
++            property real requestedHeight
              state: "normal"
              function maximize() {
@@ -63,6 +61,8 @@
                  borderThickness: units.gu(2)
                  minWidth: units.gu(15)
                  minHeight: units.gu(10)
++                defaultWidth: units.gu(20)
++                defaultHeight: units.gu(20)
                  windowId: "test-window-id"
                  screenWidth: root.width
                  screenHeight: root.height
@@ -87,22 +87,41 @@
      Loader {
          id: windowLoader
          sourceComponent: fakeWindowComponent
++        active: windowLoaderCheckbox.checked
+     }
--    MouseTouchEmulationCheckbox {
--        checked: false
--        color: "black"
++    Column {
++        MouseTouchEmulationCheckbox {
++            checked: false
++            color: "black"
++        }
++        RowLayout {
++            Layout.fillWidth: true
++            CheckBox {
++                id: windowLoaderCheckbox
++                checked: true
++                activeFocusOnPress: false
++            }
++            Label {
++                id: label
++                color: "black"
++                text: "Window loader active"
++                anchors.verticalCenter: parent.verticalCenter
++            }
++        }
+     }
      UnityTestCase {
          name: "WindowResizeArea"
          when: windowShown
++        property var fakeWindow: windowLoader.item
++
          function init() {
              fakeWindow.x = units.gu(20)
              fakeWindow.y = units.gu(20)
--            fakeWindow.width = units.gu(20)
--            fakeWindow.height = units.gu(20)
++            fakeWindow.requestedWidth = units.gu(20)
++            fakeWindow.requestedHeight = units.gu(20)
+         }
          function test_resizeWindowRightBottom_data() {
@@ -188,7 +207,7 @@
          function test_resizeSmallerAndLarger_data() {
              return [
                  { tag: "topLeft", startX: -1, startY: -1, dx: units.gu(15), dy: units.gu(15) },
--                { tag: "bottomRight", startX: fakeWindow.width + 1, startY: fakeWindow.height + 1, dx: -units.gu(15), dy: -units.gu(15) }
++                { tag: "bottomRight", startX: units.gu(20) + 1, startY: units.gu(20) + 1, dx: -units.gu(15), dy: -units.gu(15) }
+             ]
+         }
 === modified file 'tests/qmltests/tst_Shell.qml'
 --- tests/qmltests/tst_Shell.qml	2015-11-12 20:40:49 +0000
 +++ tests/qmltests/tst_Shell.qml	2015-11-24 17:51:40 +0000
@@ -954,6 +954,22 @@
              removeTimeConstraintsFromDirectionalDragAreas(greeter);
+         }
++        function revealLauncherByEdgePushWithMouse() {
++            var launcher = findChild(shell, "launcher");
++            verify(launcher);
++
++            // Place the mouse against the window/screen edge and push beyond the barrier threshold
++            mouseMove(shell, 0, shell.height / 2);
++            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * 1.1);
++
++            var panel = findChild(launcher, "launcherPanel");
++            verify(panel);
++
++            // wait until it gets fully extended
++            tryCompare(panel, "x", 0);
++            tryCompare(launcher, "state", "visibleTemporary");
++        }
++
          function test_focusRequestedHidesGreeter() {
              loadShell("phone");
              swipeAwayGreeter();
@@ -1713,8 +1729,7 @@
              tryCompare(desktopSpread, "state", "altTab")
--            mouseMove(shell, 0, shell.height / 2);
--            tryCompare(launcher, "state", "visibleTemporary")
++            revealLauncherByEdgePushWithMouse();
              waitForRendering(shell)
              mouseClick(bfb, bfb.width / 2, bfb.height / 2)
@@ -1777,15 +1792,10 @@
              tryCompare(panelButtons, "visible", false);
              appDelegate.maximize(false);
--            tryCompare(panelButtons, "visible", true);
              shell.usageScenario = "phone";
              waitForRendering(shell);
              tryCompare(panelButtons, "visible", false);
--
--            shell.usageScenario = "desktop";
--            waitForRendering(shell);
--            tryCompare(panelButtons, "visible", true);
+         }
          function test_lockingGreeterHidesPanelButtons() {
@@ -1799,15 +1809,10 @@
              tryCompare(panelButtons, "visible", false);
              appDelegate.maximize(false);
--            tryCompare(panelButtons, "visible", true);
              LightDM.Greeter.showGreeter();
              waitForRendering(shell);
              tryCompare(panelButtons, "visible", false);
--
--            LightDM.Greeter.hideGreeter();
--            waitForRendering(shell);
--            tryCompare(panelButtons, "visible", true);
+         }
          function test_cantMoveWindowUnderPanel() {