Unity 8

qml/Stages/ApplicationWindow.qml (+27/-1)
qml/Stages/DecoratedWindow.qml (+7/-2)
qml/Stages/DesktopStage.qml (+9/-9)
qml/Stages/SessionContainer.qml (+25/-1)
qml/Stages/SurfaceContainer.qml (+56/-4)
qml/Stages/WindowResizeArea.qml (+65/-20)
tests/mocks/Unity/Application/MirSurface.cpp (+52/-0)
tests/mocks/Unity/Application/MirSurface.h (+16/-0)
tests/qmltests/Stages/tst_DesktopStage.qml (+16/-1)
tests/qmltests/Stages/tst_WindowResizeArea.qml (+31/-12)

To merge this branch:

bzr merge lp:~dandrader/unity8/noStretchOnResize

Undecided

Fix Released

Link a bug report

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

This proposal supersedes a proposal from 2015-10-14.

Commit Message

Don't stretch application surfaces when resizing

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?

Not applicable

PS Jenkins bot (ps-jenkins) wrote on 2015-09-18: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2015-09-23: Posted in a previous version of this proposal

When resizing I can see the panel and the dropshadow resizing faster than the content. I think it would be better to not resize those either until the surface has caught up.

Other than that, it seems to work fine.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-09-23: Posted in a previous version of this proposal

On 23/09/2015 07:31, Michael Zanetti wrote:
> Review: Needs Fixing
>
> When resizing I can see the panel and the dropshadow resizing faster than the content. I think it would be better to not resize those either until the surface has caught up.
>
> Other than that, it seems to work fine.

It's a design decision: should we show something like a translucent
orang rect that tightly follows the mouse pointer (therefore showing
shell's responsiveness and a smooth animation) or have the window stick
to the surface size (as you prefer, but risking showing a stuttering,
unresponsive, shell)?

I don't have a strong opinion on that, but I do prefer first option. But
I'm ok with your preference as well. Any of those are better than the
current state. We should get design input on that (not sure *how* to do
that)

kevin gunn (kgunn72) wrote on 2015-09-23: Posted in a previous version of this proposal

> On 23/09/2015 07:31, Michael Zanetti wrote:
> > Review: Needs Fixing
> >
> > When resizing I can see the panel and the dropshadow resizing faster than
> the content. I think it would be better to not resize those either until the
> surface has caught up.
> >
> > Other than that, it seems to work fine.
>
> It's a design decision: should we show something like a translucent
> orang rect that tightly follows the mouse pointer (therefore showing
> shell's responsiveness and a smooth animation) or have the window stick
> to the surface size (as you prefer, but risking showing a stuttering,
> unresponsive, shell)?
>
> I don't have a strong opinion on that, but I do prefer first option. But
> I'm ok with your preference as well. Any of those are better than the
> current state. We should get design input on that (not sure *how* to do
> that)

i would vote we land for the speedy soln now, and then log a bug subsequent to this landing outlining the choices between speed vs nice tight animation tween window/shadow

Albert Astals Cid (aacid) wrote on 2015-10-08: Posted in a previous version of this proposal

Text conflict in CMakeLists.txt
1 conflicts encountered.

Daniel d'Andrada (dandrader) wrote on 2015-10-14: Posted in a previous version of this proposal

> When resizing I can see the panel and the dropshadow resizing faster than the
> content. I think it would be better to not resize those either until the
> surface has caught up.
>
> Other than that, it seems to work fine.

Now it's exactly what you asked for.

PS Jenkins bot (ps-jenkins) wrote on 2015-10-14: Posted in a previous version of this proposal

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

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2015-10-16:

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

review: Needs Fixing (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2015-10-22:

looks mostly good. some leftovers in the code to clean up. see inline.

still need to test it on the real qtmir

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2015-10-22:

the ShellView changes are part of the prerequisite already[1]. I don't know why launchpad didn't update the web diff.

[1] - http://bazaar.launchpad.net/~unity-team/unity8/externalMonitor/view/head:/src/ShellView.cpp

Daniel d'Andrada (dandrader) wrote on 2015-10-22:

All comments addressed. Had to rebase to keep the commit stack plain and simple so that launchpad didn't get confused (new you no longer see ShellView changes in the web diff).

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

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

review: Needs Fixing (continuous-integration)

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

Close, one issue:

When a window is slow to resize, resize it from the top-left corner towards the right (making the window smaller). Release the mouse before the actual resizing has happened. It will catch up resizing on the right edge instead of the left.

This can be reproduced with tryDesktopStage, but it's easiest/most notable when resizing the dash on top of QtMir (also reproducible with other apps tho).

review: Needs Fixing

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

On 23/10/2015 11:18, Michael Zanetti wrote:
> When a window is slow to resize, resize it from the top-left corner towards the right (making the window smaller). Release the mouse before the actual resizing has happened. It will catch up resizing on the right edge instead of the left.

Knonw issue. Decided to leave it that way. Let's talk over IRC

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

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

review: Needs Fixing (continuous-integration)

Michael Zanetti (mzanetti) wrote on 2015-10-26:

The last commit seems a okayish workaround to the problem. Let's go with this for now and refine it later.

One tiny issue where I'd like to hear your input:

Running on my laptop it sometimes happens that the dash doesn't start up properly (there's a bug for that, unrelated to this branch). With trunk, the window paints the background and then freezes. With this branch, the window doesn't even paint at all and we keep seeing the window decoration and shadow alone. What are your thoughts? Some potential issues?

review: Needs Information

Daniel d'Andrada (dandrader) wrote on 2015-10-26:

> The last commit seems a okayish workaround to the problem. Let's go with this
> for now and refine it later.
>
> One tiny issue where I'd like to hear your input:
>
> Running on my laptop it sometimes happens that the dash doesn't start up
> properly (there's a bug for that, unrelated to this branch). With trunk, the
> window paints the background and then freezes. With this branch, the window
> doesn't even paint at all and we keep seeing the window decoration and shadow
> alone. What are your thoughts? Some potential issues?

This is not related to this branch but to its prerequisites in qtmir.
It's a workaround for the situation where a mir surface doesn't have buffers to draw. So instead of crashing we just give a null/empty texture to Qt Scenegraph.

Michael Zanetti (mzanetti) wrote on 2015-10-27:

OK. Let's get this in then.

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

no, inter-project deps. I've ran related tests and they seem fine

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

yes

review: Approve

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

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

review: Needs Fixing (continuous-integration)

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

Note: was already top approved

Text conflict in qml/Stages/DesktopStage.qml
Text conflict in qml/Stages/WindowResizeArea.qml
Text conflict in tests/mocks/Unity/Application/MirSurface.h
Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
Text conflict in tests/qmltests/Stages/tst_WindowResizeArea.qml
5 conflicts encountered.

review: Needs Fixing

lp:~dandrader/unity8/noStretchOnResize updated on 2015-11-06

2010. By Daniel d'Andrada on 2015-11-06: Merge trunk
2011. By Daniel d'Andrada on 2015-11-06: Fix typo

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

> Note: was already top approved
>
> Text conflict in qml/Stages/DesktopStage.qml
> Text conflict in qml/Stages/WindowResizeArea.qml
> Text conflict in tests/mocks/Unity/Application/MirSurface.h
> Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
> Text conflict in tests/qmltests/Stages/tst_WindowResizeArea.qml
> 5 conflicts encountered.

Fixed, thanks.

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/6669/rebuild

review: Needs Fixing (continuous-integration)

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/6676/rebuild

review: Needs Fixing (continuous-integration)

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

CI says

tests/mocks/Unity/Application/MirSurfaceItem.h:65:5: error: 'FillMode' does not name a type
FillMode fillMode() const override;

Any idea what's wrong here?

review: Needs Information

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

On 09/11/2015 08:04, Albert Astals Cid wrote:
> Review: Needs Information
>
> CI says
>
> tests/mocks/Unity/Application/MirSurfaceItem.h:65:5: error: 'FillMode' does not name a type
> FillMode fillMode() const override;
>
> Any idea what's wrong here?
>
>
It's the unity-api dependency

lp:~dandrader/unity8/noStretchOnResize updated on 2015-11-09

2012. By Daniel d'Andrada on 2015-11-09: Remove dependency on MirSurfaceItem.fillMode property

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

Removed dependency on MirSurfaceItem.fillMode property as it's going to take forever for the qtmir branch that adds it to get merged.

This branch and the use of MirSurfaceItem.fillMode are independent of each other anyway. They are complementary

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

> On 09/11/2015 08:04, Albert Astals Cid wrote:
> > Review: Needs Information
> >
> > CI says
> >
> > tests/mocks/Unity/Application/MirSurfaceItem.h:65:5: error: 'FillMode' does
> not name a type
> > FillMode fillMode() const override;
> >
> > Any idea what's wrong here?
> >
> >
> It's the unity-api dependency

Just removed the dependency btw, next CI build should no longer cough on it.

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

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

review: Needs Fixing (continuous-integration)

Francis Ginther (fginther) wrote on 2015-11-09:

I've restarted this MP to work around an issue triggering generic-deb-autopilot-vivid-touch on krillin hardware.

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

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

review: Needs Fixing (continuous-integration)

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

Merged and CI is "good" again, re-top approving based on Michael's top approve.

review: Abstain

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

2013. By Daniel d'Andrada on 2015-11-20

Merge trunk

[ Albert Astals Cid ]
* Make cardWidth and cardHeight real
* Reset instead of qFatal when removing things from the middle (LP:
  #1238979)
* Warn we're using only the cache when not connected to the interwebs
[ Andrea Cimitan ]
* Add sharing widget to zoomable image and video playback
[ Daniel d'Andrada ]
* Cursor: properly initialize hotspot position (LP: #1510407)
* Update GSettings mock in tst_OrientedShell
[ Lukáš Tinkl ]
* Restore windows when activating from the spread, maintain a focus
  stack
[ Michael Terry ]
* Make a few DBus calls asynchronous, for a smoother UX.
[ Michael Zanetti ]
* Add a warning dialog when disconnecting the external monitor.
* added icon for the dash (LP: #1488146)
* prevent windows to be moved under the panel (LP: #1438465)
* update inputinfo api to the latest upstream snapshot
* use UbuntuNumberAnimations instead of linear ones for window state
  transitions (LP: #1497097)

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/6775/rebuild

review: Needs Fixing (continuous-integration)

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 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2015-10-26 09:59:50 +0000
 +++ qml/Stages/ApplicationWindow.qml	2015-11-20 13:05:20 +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
@@ -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-20 13:05:20 +0000
@@ -23,6 +23,9 @@
  FocusScope {
      id: root
++    width: applicationWindow.width
++    height: (root.decorationShown ? decoration.height : 0) + applicationWindow.height
++
      property alias window: applicationWindow
      property alias application: applicationWindow.application
      property alias active: decoration.active
@@ -32,6 +35,9 @@
      property bool highlightShown: false
      property real shadowOpacity: 1
++    property alias requestedWidth: applicationWindow.requestedWidth
++    property real requestedHeight
++
      signal close()
      signal maximize()
      signal minimize()
@@ -82,8 +88,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/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2015-11-12 20:40:49 +0000
 +++ qml/Stages/DesktopStage.qml	2015-11-20 13:05:20 +0000
@@ -219,9 +219,11 @@
                  objectName: "appDelegate_" + appId
                  z: ApplicationManager.count - index
                  y: units.gu(3)
--                width: units.gu(60)
--                height: units.gu(50)
--                focus: appId === priv.focusedAppId
++                width: decoratedWindow.width
++                height: decoratedWindow.height
++                property alias requestedWidth: decoratedWindow.requestedWidth
++                property alias requestedHeight: decoratedWindow.requestedHeight
++                focus: model.appId === priv.focusedAppId
                  QtObject {
                      id: appDelegatePrivate
@@ -325,7 +327,7 @@
                          PropertyChanges {
                              target: appDelegate;
                              x: 0; y: 0;
--                            width: root.width; height: root.height;
++                            requestedWidth: root.width; requestedHeight: root.height;
                              visuallyMinimized: false;
                              visuallyMaximized: true
+                         }
@@ -355,14 +357,14 @@
                          to: "normal"
                          enabled: appDelegate.animationsEnabled
                          PropertyAction { target: appDelegate; properties: "visuallyMinimized,visuallyMaximized" }
--                        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 }
                      },
                      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 }
++                            UbuntuNumberAnimation { target: appDelegate; properties: "x,y,opacity,requestedWidth,requestedHeight,scale"; duration: UbuntuAnimation.FastDuration }
                              PropertyAction { target: appDelegate; property: "visuallyMaximized" }
+                         }
                      },
@@ -371,7 +373,7 @@
                          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: {
@@ -410,8 +412,6 @@
                      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
 === modified file 'qml/Stages/SessionContainer.qml'
 --- qml/Stages/SessionContainer.qml	2015-09-29 12:28:10 +0000
 +++ qml/Stages/SessionContainer.qml	2015-11-20 13:05:20 +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-20 13:05:20 +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/WindowResizeArea.qml'
 --- qml/Stages/WindowResizeArea.qml	2015-11-09 10:52:53 +0000
 +++ qml/Stages/WindowResizeArea.qml	2015-11-20 13:05:20 +0000
@@ -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/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-20 13:05:20 +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-20 13:05:20 +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;
      };
 === 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-20 13:05:20 +0000
@@ -17,7 +17,7 @@
  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
@@ -82,6 +82,21 @@
          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;
++                    }
++                }
++            }
++
++            Divider {}
++
              Repeater {
                  model: ApplicationManager.availableApplications
                  ApplicationCheckBox {
 === 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-20 13:05:20 +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) }
+             ]
+         }