Unity 8

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

sizeHints
Merge into trunk

Proposed by Daniel d'Andrada on 2015-11-26

Status:

Superseded

Proposed branch:

lp:~dandrader/unity8/sizeHints

Merge into:

lp:unity8

Diff against target:

1043 lines (+651/-80)

15 files modified

CMakeLists.txt (+1/-1)
debian/control (+3/-3)
qml/Stages/ApplicationWindow.qml (+7/-0)
qml/Stages/DecoratedWindow.qml (+7/-0)
qml/Stages/DesktopStage.qml (+6/-0)
qml/Stages/WindowResizeArea.qml (+95/-16)
tests/mocks/Unity/Application/MirSurface.cpp (+48/-0)
tests/mocks/Unity/Application/MirSurface.h (+21/-0)
tests/mocks/Unity/Application/SurfaceManager.cpp (+56/-0)
tests/mocks/Unity/Application/SurfaceManager.h (+40/-0)
tests/qmltests/Stages/SizeHintField.qml (+33/-0)
tests/qmltests/Stages/SurfaceManagerControls.qml (+33/-0)
tests/qmltests/Stages/SurfaceManagerField.qml (+40/-0)
tests/qmltests/Stages/tst_DesktopStage.qml (+36/-30)
tests/qmltests/Stages/tst_WindowResizeArea.qml (+225/-30)

To merge this branch:

bzr merge lp:~dandrader/unity8/sizeHints

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-12-14
Albert Astals Cid (community)	merges fine		Abstain on 2015-12-14
Lukáš Tinkl (community)		2015-11-26	Approve on 2015-12-03
Review via email: mp+278743@code.launchpad.net

This proposal has been superseded by a proposal from 2016-02-03.

Commit Message

Window Size Hints

Description of the Change

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

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

Run "make tryWindowResizeArea" and "make tryDesktopStage"

For live testing, use the test application in lp:~dandrader/+junk/sizeHintsDemo
Build it with "qmake && make"
Run "./sizeHintsDemo --help" for command line options.

There are two things to test:
1 - size hints set at start up (use command line for that)
2 - size hints set/changed while after the window has been shown. Use GUI for that.

* 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-11-26:

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

review: Needs Fixing (continuous-integration)

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

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

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

On 30/11/2015 06:30, Albert Astals Cid wrote:
> Text conflict in qml/Stages/DesktopStage.qml
> Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
> 2 conflicts encountered.

Fixed.

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

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

review: Needs Fixing (continuous-integration)

Lukáš Tinkl (lukas-kde) wrote on 2015-12-01:

+++ qml/Stages/WindowResizeArea.qml

+ property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth

(and the others in the private "d" object)

Shouldn't they be readonly? After all they just calculate and return values

review: Needs Information

Daniel d'Andrada (dandrader) wrote on 2015-12-01:

On 01/12/2015 14:28, Lukáš Tinkl wrote:
> Review: Needs Information
>
> +++ qml/Stages/WindowResizeArea.qml
>
> + property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth
>
> (and the others in the private "d" object)
>
> Shouldn't they be readonly? After all they just calculate and return values

Right, done.

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

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

review: Needs Fixing (continuous-integration)

Lukáš Tinkl (lukas-kde) wrote on 2015-12-02:

In make tryShell, I can't type anything into the controls that should set the min/max width/height. The controls just don't accept any input

review: Needs Fixing

Lukáš Tinkl (lukas-kde) wrote on 2015-12-02:

Also, the description mentions "make tryWindowSizeHint" which doesn't exist, co can't test either :/

review: Needs Fixing

Lukáš Tinkl (lukas-kde) wrote on 2015-12-02:

Tested it with a real app (dialer) which has both minimum and maximum size set. Resizing works fine within those bounds but the window can still be maximized... which kind of defeats the purpose of restricting the window width/height. I guess this needs fixing too

review: Needs Fixing

Lukáš Tinkl (lukas-kde) wrote on 2015-12-03:

After some discussion, let's leave the window flags for later, when the window management situation settles a bit.

* 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, unsatisfied unity-api version

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

Yes

review: Approve

Albert Astals Cid (aacid) wrote on 2015-12-14:

Note for later: This was already top-approved

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

review: Needs Fixing

lp:~dandrader/unity8/sizeHints updated on 2015-12-14

2077. By Daniel d'Andrada on 2015-12-14

Merge trunk

[ Albert Astals Cid ]
* Allow dragging launcher items with the quicklist open (LP: #1250861)
* Create ratings on demand instead of all at the same time (LP:
  #1519898, #1492214)
* LVWPH: Process correctly section changes (LP: #1519893)
* Make sure that unfavoriting a scope gives us the next one
* Move images only used in tests to tests folder
[ Andrea Cimitan ]
* Add shadows to ubuntu store icon
[ Daniel d'Andrada ]
* MirSurfaceItem got a new property: fillMode (LP: #1497083)
* Session can have multiple surfaces now
* plugins/Cursor: Do not force loading a specific cursor size (LP:
  #1517878)
[ Lukáš Tinkl ]
* Indicators convergence: use the "phone" profile everywhere (LP:
  #1520492)
[ Michael Terry ]
* Let qtmir know which apps are exempt from the lifecycle management.
  This way, it can manage its own wakelocks better (and stop
  preventing the system from deep sleeping).
[ Michael Zanetti ]
* Use proper z ordering instead of app index for occlusion detection
* add some debug prints to the uinput backend
* drop the ignoredMice hack again (LP: #1521580)
[ Michał Sawicz ]
* Let qtmir know which apps are exempt from the lifecycle management.
  This way, it can manage its own wakelocks better (and stop
  preventing the system from deep sleeping).
* Update .pot file in debian/clean when in train
* Rebuild against Qt 5.5.1.

2078. By Daniel d'Andrada on 2015-12-14

Update unity-api version requirements

Daniel d'Andrada (dandrader) wrote on 2015-12-14:

> Note for later: This was already top-approved
>
> Text conflict in tests/qmltests/Stages/tst_DesktopStage.qml
> 1 conflicts encountered.

Fixed.

Albert Astals Cid (aacid) wrote on 2015-12-14:

Re-top approving since it merges fine now.

review: Abstain (merges fine)

PS Jenkins bot (ps-jenkins) wrote on 2015-12-14:

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

2078. By Daniel d'Andrada on 2015-12-14: Update unity-api version requirements

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 'CMakeLists.txt'
 --- CMakeLists.txt	2015-12-03 19:36:58 +0000
 +++ CMakeLists.txt	2015-12-14 10:37:31 +0000
@@ -57,7 +57,7 @@
  find_package(Qt5Concurrent 5.4 REQUIRED)
  find_package(Qt5Sql 5.4 REQUIRED)
--pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=12)
++pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=13)
  # Standard install paths
  include(GNUInstallDirs)
 === modified file 'debian/control'
 --- debian/control	2015-12-08 15:37:20 +0000
 +++ debian/control	2015-12-14 10:37:31 +0000
@@ -29,7 +29,7 @@
                 libqt5xmlpatterns5-dev,
                 libsystemsettings-dev,
                 libudev-dev,
--               libunity-api-dev (>= 7.104),
++               libunity-api-dev (>= 7.105),
                 libusermetricsoutput1-dev,
                 libxcb1-dev,
                 pkg-config,
@@ -128,7 +128,7 @@
           qtdeclarative5-ubuntu-ui-toolkit-plugin (>= 1.3.1627) | qtdeclarative5-ubuntu-ui-toolkit-plugin-gles (>= 1.3.1627),
           qtdeclarative5-unity-notifications-plugin (>= 0.1.2) | unity-notifications-impl,
           ubuntu-thumbnailer-impl-0,
--         unity-application-impl-12,
++         unity-application-impl-13,
           unity-notifications-impl-3,
           unity-plugin-scopes | unity-scopes-impl,
           unity-scopes-impl-7,
@@ -174,7 +174,7 @@
  Depends: ${misc:Depends},
           ${shlibs:Depends},
  Provides: unity-application-impl,
--          unity-application-impl-12,
++          unity-application-impl-13,
  Replaces: unity8-autopilot (<< 8.02+15.04.20150422-0ubuntu1)
  Description: Fake environment for running Unity 8 shell
   Provides fake implementations of some QML modules used by Unity 8 shell
 === modified file 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2015-11-23 13:52:39 +0000
 +++ qml/Stages/ApplicationWindow.qml	2015-12-14 10:37:31 +0000
@@ -37,6 +37,13 @@
      property int requestedWidth: -1
      property int requestedHeight: -1
++    readonly property int minimumWidth: sessionContainer.surface ? sessionContainer.surface.minimumWidth : 0
++    readonly property int minimumHeight: sessionContainer.surface ? sessionContainer.surface.minimumHeight : 0
++    readonly property int maximumWidth: sessionContainer.surface ? sessionContainer.surface.maximumWidth : 0
++    readonly property int maximumHeight: sessionContainer.surface ? sessionContainer.surface.maximumHeight : 0
++    readonly property int widthIncrement: sessionContainer.surface ? sessionContainer.surface.widthIncrement : 0
++    readonly property int heightIncrement: sessionContainer.surface ? sessionContainer.surface.heightIncrement : 0
++
      QtObject {
          id: d
 === modified file 'qml/Stages/DecoratedWindow.qml'
 --- qml/Stages/DecoratedWindow.qml	2015-11-23 15:09:45 +0000
 +++ qml/Stages/DecoratedWindow.qml	2015-12-14 10:37:31 +0000
@@ -39,6 +39,13 @@
      property alias requestedWidth: applicationWindow.requestedWidth
      property real requestedHeight
++    property alias minimumWidth: applicationWindow.minimumWidth
++    readonly property int minimumHeight: (root.decorationShown ? decoration.height : 0) + applicationWindow.minimumHeight
++    property alias maximumWidth: applicationWindow.maximumWidth
++    readonly property int maximumHeight: (root.decorationShown ? decoration.height : 0) + applicationWindow.maximumHeight
++    property alias widthIncrement: applicationWindow.widthIncrement
++    property alias heightIncrement: applicationWindow.heightIncrement
++
      signal close()
      signal maximize()
      signal minimize()
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2015-11-30 17:27:47 +0000
 +++ qml/Stages/DesktopStage.qml	2015-12-14 10:37:31 +0000
@@ -247,6 +247,12 @@
                  height: decoratedWindow.height
                  property alias requestedWidth: decoratedWindow.requestedWidth
                  property alias requestedHeight: decoratedWindow.requestedHeight
++                property alias minimumWidth: decoratedWindow.minimumWidth
++                property alias minimumHeight: decoratedWindow.minimumHeight
++                property alias maximumWidth: decoratedWindow.maximumWidth
++                property alias maximumHeight: decoratedWindow.maximumHeight
++                property alias widthIncrement: decoratedWindow.widthIncrement
++                property alias heightIncrement: decoratedWindow.heightIncrement
                  QtObject {
                      id: appDelegatePrivate
 === modified file 'qml/Stages/WindowResizeArea.qml'
 --- qml/Stages/WindowResizeArea.qml	2015-11-23 13:52:39 +0000
 +++ qml/Stages/WindowResizeArea.qml	2015-12-14 10:37:31 +0000
@@ -72,8 +72,8 @@
          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.requestedWidth = Math.min(Math.max(windowGeometry.width, d.minimumWidth), screenWidth);
++        target.requestedHeight = Math.min(Math.max(windowGeometry.height, d.minimumHeight), 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)
@@ -91,6 +91,65 @@
      QtObject {
          id: d
++
++        readonly property int maxSafeInt: 2147483647
++        readonly property int maxSizeIncrement: units.gu(40)
++
++        readonly property int minimumWidth: root.target ? Math.max(root.minWidth, root.target.minimumWidth) : root.minWidth
++        onMinimumWidthChanged: {
++            if (target.requestedWidth < minimumWidth) {
++                target.requestedWidth = minimumWidth;
++            }
++        }
++        readonly property int minimumHeight: root.target ? Math.max(root.minHeight, root.target.minimumHeight) : root.minHeight
++        onMinimumHeightChanged: {
++            if (target.requestedHeight < minimumHeight) {
++                target.requestedHeight = minimumHeight;
++            }
++        }
++        readonly property int maximumWidth: root.target && root.target.maximumWidth >= minimumWidth && root.target.maximumWidth > 0
++            ? root.target.maximumWidth : maxSafeInt
++        onMaximumWidthChanged: {
++            if (target.requestedWidth > maximumWidth) {
++                target.requestedWidth = maximumWidth;
++            }
++        }
++        readonly property int maximumHeight: root.target && root.target.maximumHeight >= minimumHeight && root.target.maximumHeight > 0
++            ? root.target.maximumHeight : maxSafeInt
++        onMaximumHeightChanged: {
++            if (target.requestedHeight > maximumHeight) {
++                target.requestedHeight = maximumHeight;
++            }
++        }
++        readonly property int widthIncrement: {
++            if (!root.target) {
++                return 1;
++            }
++            if (root.target.widthIncrement > 0) {
++                if (root.target.widthIncrement < maxSizeIncrement) {
++                    return root.target.widthIncrement;
++                } else {
++                    return maxSizeIncrement;
++                }
++            } else {
++                return 1;
++            }
++        }
++        readonly property int heightIncrement: {
++            if (!root.target) {
++                return 1;
++            }
++            if (root.target.heightIncrement > 0) {
++                if (root.target.heightIncrement < maxSizeIncrement) {
++                    return root.target.heightIncrement;
++                } else {
++                    return maxSizeIncrement;
++                }
++            } else {
++                return 1;
++            }
++        }
++
          property bool leftBorder: false
          property bool rightBorder: false
          property bool topBorder: false
@@ -209,38 +268,58 @@
          var pos = mapToItem(target.parent, mouse.x, mouse.y);
--        var deltaX = pos.x - d.startMousePosX;
--        var deltaY = pos.y - d.startMousePosY;
++        var deltaX = Math.floor((pos.x - d.startMousePosX) / d.widthIncrement) * d.widthIncrement;
++        var deltaY = Math.floor((pos.y - d.startMousePosY) / d.heightIncrement) * d.heightIncrement;
          if (d.leftBorder) {
              var newTargetX = d.startX + deltaX;
--            if (target.x + target.width > newTargetX + minWidth) {
--                target.requestedWidth = target.x + target.width - newTargetX;
++            var rightBorderX = target.x + target.width;
++            if (rightBorderX > newTargetX + d.minimumWidth) {
++                if (rightBorderX  < newTargetX + d.maximumWidth) {
++                    target.requestedWidth = rightBorderX - newTargetX;
++                } else {
++                    target.requestedWidth = d.maximumWidth;
++                }
              } else {
--                target.requestedWidth = minWidth;
++                target.requestedWidth = d.minimumWidth;
+             }
          } else if (d.rightBorder) {
--            if (d.startWidth + deltaX >= minWidth) {
--                target.requestedWidth = d.startWidth + deltaX;
++            var newWidth = d.startWidth + deltaX;
++            if (newWidth > d.minimumWidth) {
++                if (newWidth < d.maximumWidth) {
++                    target.requestedWidth = newWidth;
++                } else {
++                    target.requestedWidth = d.maximumWidth;
++                }
              } else {
--                target.requestedWidth = minWidth;
++                target.requestedWidth = d.minimumWidth;
+             }
+         }
          if (d.topBorder) {
              var newTargetY = d.startY + deltaY;
--            if (target.y + target.height > newTargetY + minHeight) {
--                target.requestedHeight = target.y + target.height - newTargetY;
++            var bottomBorderY = target.y + target.height;
++            if (bottomBorderY > newTargetY + d.minimumHeight) {
++                if (bottomBorderY < newTargetY + d.maximumHeight) {
++                    target.requestedHeight = bottomBorderY - newTargetY;
++                } else {
++                    target.requestedHeight = d.maximumHeight;
++                }
              } else {
--                target.requestedHeight = minHeight;
++                target.requestedHeight = d.minimumHeight;
+             }
          } else if (d.bottomBorder) {
--            if (d.startHeight + deltaY >= minHeight) {
--                target.requestedHeight = d.startHeight + deltaY;
++            var newHeight = d.startHeight + deltaY;
++            if (newHeight > d.minimumHeight) {
++                if (newHeight < d.maximumHeight) {
++                    target.requestedHeight = newHeight;
++                } else {
++                    target.requestedHeight = d.maximumHeight;
++                }
              } else {
--                target.requestedHeight = minHeight;
++                target.requestedHeight = d.minimumHeight;
+             }
+         }
+     }
 === modified file 'tests/mocks/Unity/Application/MirSurface.cpp'
 --- tests/mocks/Unity/Application/MirSurface.cpp	2015-11-06 15:52:24 +0000
 +++ tests/mocks/Unity/Application/MirSurface.cpp	2015-12-14 10:37:31 +0000
@@ -266,3 +266,51 @@
+         }
+     }
+ }
++
++void MirSurface::setMinimumWidth(int value)
++{
++    if (value != m_minimumWidth) {
++        m_minimumWidth = value;
++        Q_EMIT minimumWidthChanged(m_minimumWidth);
++    }
++}
++
++void MirSurface::setMaximumWidth(int value)
++{
++    if (value != m_maximumWidth) {
++        m_maximumWidth = value;
++        Q_EMIT maximumWidthChanged(m_maximumWidth);
++    }
++}
++
++void MirSurface::setMinimumHeight(int value)
++{
++    if (value != m_minimumHeight) {
++        m_minimumHeight = value;
++        Q_EMIT minimumHeightChanged(m_minimumHeight);
++    }
++}
++
++void MirSurface::setMaximumHeight(int value)
++{
++    if (value != m_maximumHeight) {
++        m_maximumHeight = value;
++        Q_EMIT maximumHeightChanged(m_maximumHeight);
++    }
++}
++
++void MirSurface::setWidthIncrement(int value)
++{
++    if (value != m_widthIncrement) {
++        m_widthIncrement = value;
++        Q_EMIT widthIncrementChanged(m_widthIncrement);
++    }
++}
++
++void MirSurface::setHeightIncrement(int value)
++{
++    if (value != m_heightIncrement) {
++        m_heightIncrement = value;
++        Q_EMIT heightIncrementChanged(m_heightIncrement);
++    }
++}
 === modified file 'tests/mocks/Unity/Application/MirSurface.h'
 --- tests/mocks/Unity/Application/MirSurface.h	2015-11-06 15:52:24 +0000
 +++ tests/mocks/Unity/Application/MirSurface.h	2015-12-14 10:37:31 +0000
@@ -66,6 +66,13 @@
      Mir::OrientationAngle orientationAngle() const override;
      void setOrientationAngle(Mir::OrientationAngle) override;
++    int minimumWidth() const override { return m_minimumWidth; }
++    int minimumHeight() const override { return m_minimumHeight; }
++    int maximumWidth() const override { return m_maximumWidth; }
++    int maximumHeight() const override { return m_maximumHeight; }
++    int widthIncrement() const override { return m_widthIncrement; }
++    int heightIncrement() const override { return m_heightIncrement; }
++
      ////
      // API for tests
@@ -82,6 +89,13 @@
      bool isSlowToResize() const;
      void setSlowToResize(bool value);
++    Q_INVOKABLE void setMinimumWidth(int);
++    Q_INVOKABLE void setMaximumWidth(int);
++    Q_INVOKABLE void setMinimumHeight(int);
++    Q_INVOKABLE void setMaximumHeight(int);
++    Q_INVOKABLE void setWidthIncrement(int);
++    Q_INVOKABLE void setHeightIncrement(int);
++
      /////
      // internal mock stuff
@@ -125,6 +139,13 @@
      int m_width;
      int m_height;
++    int m_minimumWidth{0};
++    int m_minimumHeight{0};
++    int m_maximumWidth{0};
++    int m_maximumHeight{0};
++    int m_widthIncrement{0};
++    int m_heightIncrement{0};
++
      bool m_slowToResize;
      QTimer m_delayedResizeTimer;
      QSize m_delayedResize;
 === modified file 'tests/mocks/Unity/Application/SurfaceManager.cpp'
 --- tests/mocks/Unity/Application/SurfaceManager.cpp	2015-09-02 08:04:41 +0000
 +++ tests/mocks/Unity/Application/SurfaceManager.cpp	2015-12-14 10:37:31 +0000
@@ -46,6 +46,14 @@
          MirSurface* surface = qobject_cast<MirSurface*>(obj);
          Q_EMIT surfaceDestroyed(surface);
      });
++
++    surface->setMinimumWidth(m_newSurfaceMinimumWidth);
++    surface->setMaximumWidth(m_newSurfaceMaximumWidth);
++    surface->setMinimumHeight(m_newSurfaceMinimumHeight);
++    surface->setMaximumHeight(m_newSurfaceMaximumHeight);
++    surface->setWidthIncrement(m_newSurfaceWidthIncrement);
++    surface->setHeightIncrement(m_newSurfaceHeightIncrement);
++
      Q_EMIT surfaceCreated(surface);
      return surface;
+ }
@@ -62,3 +70,51 @@
+     }
      return m_virtualKeyboard;
+ }
++
++void SurfaceManager::setNewSurfaceMinimumWidth(int value)
++{
++    if (m_newSurfaceMinimumWidth != value) {
++        m_newSurfaceMinimumWidth = value;
++        Q_EMIT newSurfaceMinimumWidthChanged(m_newSurfaceMinimumWidth);
++    }
++}
++
++void SurfaceManager::setNewSurfaceMaximumWidth(int value)
++{
++    if (m_newSurfaceMaximumWidth != value) {
++        m_newSurfaceMaximumWidth = value;
++        Q_EMIT newSurfaceMaximumWidthChanged(m_newSurfaceMaximumWidth);
++    }
++}
++
++void SurfaceManager::setNewSurfaceMinimumHeight(int value)
++{
++    if (m_newSurfaceMinimumHeight != value) {
++        m_newSurfaceMinimumHeight = value;
++        Q_EMIT newSurfaceMinimumHeightChanged(m_newSurfaceMinimumHeight);
++    }
++}
++
++void SurfaceManager::setNewSurfaceMaximumHeight(int value)
++{
++    if (m_newSurfaceMaximumHeight != value) {
++        m_newSurfaceMaximumHeight = value;
++        Q_EMIT newSurfaceMaximumHeightChanged(m_newSurfaceMaximumHeight);
++    }
++}
++
++void SurfaceManager::setNewSurfaceWidthIncrement(int value)
++{
++    if (m_newSurfaceWidthIncrement != value) {
++        m_newSurfaceWidthIncrement = value;
++        Q_EMIT newSurfaceWidthIncrementChanged(m_newSurfaceWidthIncrement);
++    }
++}
++
++void SurfaceManager::setNewSurfaceHeightIncrement(int value)
++{
++    if (m_newSurfaceHeightIncrement != value) {
++        m_newSurfaceHeightIncrement = value;
++        Q_EMIT newSurfaceHeightIncrementChanged(m_newSurfaceHeightIncrement);
++    }
++}
 === modified file 'tests/mocks/Unity/Application/SurfaceManager.h'
 --- tests/mocks/Unity/Application/SurfaceManager.h	2015-08-03 15:00:47 +0000
 +++ tests/mocks/Unity/Application/SurfaceManager.h	2015-12-14 10:37:31 +0000
@@ -25,6 +25,14 @@
  class SurfaceManager : public QObject
+ {
      Q_OBJECT
++
++    Q_PROPERTY(int newSurfaceMinimumWidth READ newSurfaceMinimumWidth WRITE setNewSurfaceMinimumWidth NOTIFY newSurfaceMinimumWidthChanged)
++    Q_PROPERTY(int newSurfaceMaximumWidth READ newSurfaceMaximumWidth WRITE setNewSurfaceMaximumWidth NOTIFY newSurfaceMaximumWidthChanged)
++    Q_PROPERTY(int newSurfaceMinimumHeight READ newSurfaceMinimumHeight WRITE setNewSurfaceMinimumHeight NOTIFY newSurfaceMinimumHeightChanged)
++    Q_PROPERTY(int newSurfaceMaximumHeight READ newSurfaceMaximumHeight WRITE setNewSurfaceMaximumHeight NOTIFY newSurfaceMaximumHeightChanged)
++    Q_PROPERTY(int newSurfaceWidthIncrement READ newSurfaceWidthIncrement WRITE setNewSurfaceWidthIncrement NOTIFY newSurfaceWidthIncrementChanged)
++    Q_PROPERTY(int newSurfaceHeightIncrement READ newSurfaceHeightIncrement WRITE setNewSurfaceHeightIncrement NOTIFY newSurfaceHeightIncrementChanged)
++
  public:
      explicit SurfaceManager(QObject *parent = 0);
@@ -38,14 +46,46 @@
      // To be used in the tests
      Q_INVOKABLE MirSurface* inputMethodSurface();
++    int newSurfaceMinimumWidth() const { return m_newSurfaceMinimumWidth; }
++    void setNewSurfaceMinimumWidth(int value);
++
++    int newSurfaceMaximumWidth() const { return m_newSurfaceMaximumWidth; }
++    void setNewSurfaceMaximumWidth(int value);
++
++    int newSurfaceMinimumHeight() const { return m_newSurfaceMinimumHeight; }
++    void setNewSurfaceMinimumHeight(int value);
++
++    int newSurfaceMaximumHeight() const { return m_newSurfaceMaximumHeight; }
++    void setNewSurfaceMaximumHeight(int value);
++
++    int newSurfaceWidthIncrement() const { return m_newSurfaceWidthIncrement; }
++    void setNewSurfaceWidthIncrement(int);
++
++    int newSurfaceHeightIncrement() const { return m_newSurfaceHeightIncrement; }
++    void setNewSurfaceHeightIncrement(int);
++
  Q_SIGNALS:
      void countChanged();
      void surfaceCreated(MirSurface *surface);
      void surfaceDestroyed(MirSurface*surface);
++    void newSurfaceMinimumWidthChanged(int value);
++    void newSurfaceMaximumWidthChanged(int value);
++    void newSurfaceMinimumHeightChanged(int value);
++    void newSurfaceMaximumHeightChanged(int value);
++    void newSurfaceWidthIncrementChanged(int value);
++    void newSurfaceHeightIncrementChanged(int value);
++
  private:
      static SurfaceManager *the_surface_manager;
      VirtualKeyboard *m_virtualKeyboard;
++
++    int m_newSurfaceMinimumWidth{0};
++    int m_newSurfaceMaximumWidth{0};
++    int m_newSurfaceMinimumHeight{0};
++    int m_newSurfaceMaximumHeight{0};
++    int m_newSurfaceWidthIncrement{1};
++    int m_newSurfaceHeightIncrement{1};
  };
  #endif // SURFACEMANAGER_H
 === added file 'tests/qmltests/Stages/SizeHintField.qml'
 --- tests/qmltests/Stages/SizeHintField.qml	1970-01-01 00:00:00 +0000
 +++ tests/qmltests/Stages/SizeHintField.qml	2015-12-14 10:37:31 +0000
@@ -0,0 +1,33 @@
++/*
++ * 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
++
++Row {
++    property alias text: label.text
++    property alias value: field.text
++    spacing: units.gu(1)
++    Label {
++        id: label
++        color: "black"; anchors.verticalCenter: parent.verticalCenter
++    }
++    TextField {
++        id: field
++        text: ""; width: units.gu(8); hasClearButton: false; maximumLength: 6; inputMask: "d00000"
++    }
++}
 === added file 'tests/qmltests/Stages/SurfaceManagerControls.qml'
 --- tests/qmltests/Stages/SurfaceManagerControls.qml	1970-01-01 00:00:00 +0000
 +++ tests/qmltests/Stages/SurfaceManagerControls.qml	2015-12-14 10:37:31 +0000
@@ -0,0 +1,33 @@
++/*
++ * 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
++import Unity.Application 0.1
++
++Column {
++    id: root
++    property color textColor: "black"
++
++    Label {text: "Size hints for new surface:"; color: root.textColor; font.bold: true}
++
++    SurfaceManagerField { text: "min width"; propertyName: "newSurfaceMinimumWidth"; textColor: root.textColor }
++    SurfaceManagerField { text: "max width"; propertyName: "newSurfaceMaximumWidth"; textColor: root.textColor }
++    SurfaceManagerField { text: "min height"; propertyName: "newSurfaceMinimumHeight"; textColor: root.textColor }
++    SurfaceManagerField { text: "max height"; propertyName: "newSurfaceMaximumHeight"; textColor: root.textColor }
++    SurfaceManagerField { text: "width increment"; propertyName: "newSurfaceWidthIncrement"; textColor: root.textColor }
++    SurfaceManagerField { text: "height increment"; propertyName: "newSurfaceHeightIncrement"; textColor: root.textColor }
++}
 === added file 'tests/qmltests/Stages/SurfaceManagerField.qml'
 --- tests/qmltests/Stages/SurfaceManagerField.qml	1970-01-01 00:00:00 +0000
 +++ tests/qmltests/Stages/SurfaceManagerField.qml	2015-12-14 10:37:31 +0000
@@ -0,0 +1,40 @@
++/*
++ * 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
++import Unity.Application 0.1
++
++Row {
++    id: root
++    property alias textColor: label.color
++    property alias text: label.text
++    property string propertyName
++
++    Label {id: label; anchors.verticalCenter: parent.verticalCenter}
++    TextField {
++        width: units.gu(10); hasClearButton: false; maximumLength: 6
++        inputMask: "d00000"
++        text: ""
++        onTextChanged: {
++            if (text.length > 0) {
++                SurfaceManager[root.propertyName] = parseInt(text);
++            } else {
++                SurfaceManager[root.propertyName] = 0;
++            }
++        }
++    }
++}
 === modified file 'tests/qmltests/Stages/tst_DesktopStage.qml'
 --- tests/qmltests/Stages/tst_DesktopStage.qml	2015-12-08 15:37:51 +0000
 +++ tests/qmltests/Stages/tst_DesktopStage.qml	2015-12-14 10:37:31 +0000
@@ -88,36 +88,42 @@
              right: parent.right
+         }
--        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.lastSurface;
--                        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 {
--                    appId: modelData
--                }
++        Flickable {
++            anchors.fill: parent
++            contentHeight: controlsColumn.height
++            Column {
++                id: controlsColumn
++                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.lastSurface;
++                            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 {
++                        appId: modelData
++                    }
++                }
++
++                SurfaceManagerControls { textColor: "white" }
+             }
+         }
+     }
 === modified file 'tests/qmltests/Stages/tst_WindowResizeArea.qml'
 --- tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-11-20 13:04:46 +0000
 +++ tests/qmltests/Stages/tst_WindowResizeArea.qml	2015-12-14 10:37:31 +0000
@@ -28,7 +28,7 @@
  Item {
      id: root
      height: units.gu(60)
--    width: units.gu(60)
++    width: units.gu(85)
      Binding {
          target: PanelState
@@ -41,14 +41,20 @@
          Item {
              id: fakeWindow
--            property alias minWidth: windowResizeArea.minWidth
--            property alias minHeight: windowResizeArea.minHeight
++            property alias resizeAreaMinWidth: windowResizeArea.minWidth
++            property alias resizeAreaMinHeight: windowResizeArea.minHeight
              x: units.gu(20)
              y: units.gu(20)
              width: requestedWidth
              height: requestedHeight
              property real requestedWidth
              property real requestedHeight
++            property real minimumWidth: 0
++            property real minimumHeight: 0
++            property real maximumWidth: 0
++            property real maximumHeight: 0
++            property real widthIncrement: 0
++            property real heightIncrement: 0
              state: "normal"
              function maximize() {
@@ -80,6 +86,10 @@
                      anchors.fill: parent
                      hoverEnabled: true
+                 }
++                Text {
++                    text: parent.width + "x" + parent.height
++                    color: "white"
++                }
+             }
+         }
+     }
@@ -90,27 +100,107 @@
          active: windowLoaderCheckbox.checked
+     }
--    Column {
--        MouseTouchEmulationCheckbox {
--            checked: false
--            color: "black"
--        }
--        RowLayout {
--            Layout.fillWidth: true
--            CheckBox {
--                id: windowLoaderCheckbox
--                checked: true
--                activeFocusOnPress: false
++    Rectangle {
++        anchors.right: parent.right
++        anchors.top: parent.top
++        anchors.bottom: parent.bottom
++        width: units.gu(25)
++        color: "lightgrey"
++        Column {
++            width: parent.width
++            spacing: units.gu(1)
++            MouseTouchEmulationCheckbox {
++                checked: false
++                color: "black"
++            }
++            RowLayout {
++                Layout.fillWidth: true
++                CheckBox {
++                    id: windowLoaderCheckbox
++                    checked: true
++                    activeFocusOnPress: false
++                }
++                Label {
++                    color: "black"
++                    text: "Window loader active"
++                    anchors.verticalCenter: parent.verticalCenter
++                }
+             }
              Label {
--                id: label
++                color: "black"; font.bold: true
++                text: "Size Hints:"
++            }
++            SizeHintField { id: minWidthText; text: "min width" }
++            SizeHintField { id: maxWidthText; text: "max width" }
++            SizeHintField { id: minHeightText; text: "min height" }
++            SizeHintField { id: maxHeightText; text: "max height" }
++            SizeHintField { id: widthIncrText; text: "width incr" }
++            SizeHintField { id: heightIncrText; text: "height incr" }
++            Button {
                  color: "black"
--                text: "Window loader active"
--                anchors.verticalCenter: parent.verticalCenter
++                anchors.horizontalCenter: parent.horizontalCenter
++                text: "Apply"
++                onClicked: {
++                    var value = parseInt(minWidthText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.minimumWidth = 0;
++                    } else {
++                        windowLoader.item.resizeAreaMinWidth = 1; // get it out of the way
++                        windowLoader.item.minimumWidth = value;
++                    }
++
++                    value = parseInt(maxWidthText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.maximumWidth = 0;
++                    } else {
++                        windowLoader.item.maximumWidth = value;
++                    }
++
++                    value = parseInt(minHeightText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.minimumHeight = 0;
++                    } else {
++                        windowLoader.item.resizeAreaMinHeight = 1; // get it out of the way
++                        windowLoader.item.minimumHeight = value;
++                    }
++
++                    value = parseInt(maxHeightText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.maximumHeight = 0;
++                    } else {
++                        windowLoader.item.maximumHeight = value;
++                    }
++
++                    value = parseInt(widthIncrText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.widthIncrement = 0;
++                    } else {
++                        windowLoader.item.widthIncrement = value;
++                    }
++
++                    value = parseInt(heightIncrText.value);
++                    if (isNaN(value)) {
++                        windowLoader.item.heightIncrement = 0;
++                    } else {
++                        windowLoader.item.heightIncrement = value;
++                    }
++                }
+             }
+         }
+     }
++    SignalSpy {
++        id: windowRequestedWidthSpy
++        target: windowLoader.item
++        signalName: "onRequestedWidthChanged"
++    }
++
++    SignalSpy {
++        id: windowRequestedHeightSpy
++        target: windowLoader.item
++        signalName: "onRequestedHeightChanged"
++    }
++
      UnityTestCase {
          name: "WindowResizeArea"
          when: windowShown
@@ -122,6 +212,18 @@
              fakeWindow.y = units.gu(20)
              fakeWindow.requestedWidth = units.gu(20)
              fakeWindow.requestedHeight = units.gu(20)
++            fakeWindow.resizeAreaMinWidth = units.gu(15);
++            fakeWindow.resizeAreaMinHeight = units.gu(10);
++            fakeWindow.minimumWidth = 0;
++            fakeWindow.minimumHeight = 0;
++            fakeWindow.maximumWidth = 0;
++            fakeWindow.maximumHeight = 0;
++            fakeWindow.widthIncrement = 0;
++            fakeWindow.heightIncrement = 0;
++
++            // Our test window resizes instantly
++            compare(fakeWindow.width, fakeWindow.requestedWidth);
++            compare(fakeWindow.height, fakeWindow.requestedHeight);
+         }
          function test_resizeWindowRightBottom_data() {
@@ -143,8 +245,8 @@
              var startDragY = initialWindowY + initialWindowHeight + 1
              mouseFlick(root, startDragX, startDragY, startDragX + data.dx, startDragY + data.dy, true, true, units.gu(.5), 10);
--            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + data.dx, fakeWindow.minWidth));
--            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + data.dy, fakeWindow.minHeight));
++            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + data.dx, fakeWindow.resizeAreaMinWidth));
++            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + data.dy, fakeWindow.resizeAreaMinHeight));
              compare(fakeWindow.x, initialWindowX);
              compare(fakeWindow.y, initialWindowY);
@@ -169,11 +271,11 @@
              var startDragY = initialWindowY - 1
              mouseFlick(root, startDragX, startDragY, startDragX + data.dx, startDragY + data.dy, true, true, units.gu(.5), 10);
--            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth - data.dx, fakeWindow.minWidth));
--            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight - data.dy, fakeWindow.minHeight));
++            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth - data.dx, fakeWindow.resizeAreaMinWidth));
++            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight - data.dy, fakeWindow.resizeAreaMinHeight));
--            var maxMoveX = initialWindowWidth - fakeWindow.minWidth;
--            var maxMoveY = initialWindowHeight - fakeWindow.minHeight;
++            var maxMoveX = initialWindowWidth - fakeWindow.resizeAreaMinWidth;
++            var maxMoveY = initialWindowHeight - fakeWindow.resizeAreaMinHeight;
              compare(fakeWindow.x, Math.min(initialWindowX + data.dx, initialWindowX + maxMoveX));
              compare(fakeWindow.y, Math.min(initialWindowY + data.dy, initialWindowY + maxMoveY));
+         }
@@ -189,8 +291,8 @@
              var startDragY = initialWindowY + initialWindowHeight + 1
              mouseFlick(root, startDragX, startDragY, startDragX + resizeDelta, startDragY + resizeDelta, true, true, units.gu(.5), 10);
--            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + resizeDelta, fakeWindow.minWidth));
--            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + resizeDelta, fakeWindow.minHeight));
++            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + resizeDelta, fakeWindow.resizeAreaMinWidth));
++            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + resizeDelta, fakeWindow.resizeAreaMinHeight));
              // This will destroy the window and recreate it
              windowLoader.active = false;
@@ -198,8 +300,8 @@
              windowLoader.active = true;
              // Make sure its size is again the same as before
--            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + resizeDelta, fakeWindow.minWidth));
--            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + resizeDelta, fakeWindow.minHeight));
++            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth + resizeDelta, fakeWindow.resizeAreaMinWidth));
++            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight + resizeDelta, fakeWindow.resizeAreaMinHeight));
+         }
          // This tests if dragging smaller than minSize and then larger again, will keep the edge sticking
@@ -220,8 +322,8 @@
              var startDragX = initialWindowX + data.startX
              var startDragY = initialWindowY + data.startY
              mouseFlick(root, startDragX, startDragY, startDragX + data.dx, startDragY + data.dy, true, false, units.gu(.05), 10);
--            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth - Math.abs(data.dx), fakeWindow.minWidth));
--            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight - Math.abs(data.dy), fakeWindow.minHeight));
++            tryCompare(fakeWindow, "width", Math.max(initialWindowWidth - Math.abs(data.dx), fakeWindow.resizeAreaMinWidth));
++            tryCompare(fakeWindow, "height", Math.max(initialWindowHeight - Math.abs(data.dy), fakeWindow.resizeAreaMinHeight));
              mouseFlick(root, startDragX + data.dx, startDragY + data.dy, startDragX, startDragY, false, true, units.gu(.05), 10);
              tryCompare(fakeWindow, "width", initialWindowWidth);
              tryCompare(fakeWindow, "height", initialWindowHeight);
@@ -257,7 +359,6 @@
              fakeWindow.state = "normal"
+         }
--
          function test_restoreMovesIntoBounds_data() {
              return [
                          {tag: "left off", x: -units.gu(5), y: units.gu(5), w: units.gu(10), h: units.gu(10)},
@@ -290,5 +391,99 @@
              waitForRendering(root)
+         }
++
++        /*
++            Tests that even though you dragged the window bottom right corner continously (ie,
++            through multiple intermediate steps), its (requested) width and height changed only
++            once. And, furthermore, its dimensions increased by a multiple of its size (width
++            and height) increment value.
++         */
++        function test_sizeIncrement() {
++            var initialWindowX = fakeWindow.x;
++            var initialWindowY = fakeWindow.y;
++            var initialWindowWidth = fakeWindow.width
++            var initialWindowHeight = fakeWindow.height
++
++            fakeWindow.widthIncrement = 70;
++            fakeWindow.heightIncrement = 70;
++
++            var startDragX = initialWindowX + initialWindowWidth + 1
++            var startDragY = initialWindowY + initialWindowHeight + 1
++            var deltaX = 100;
++            var deltaY = 100;
++
++            windowRequestedWidthSpy.clear();
++            verify(windowRequestedWidthSpy.valid);
++
++            windowRequestedHeightSpy.clear();
++            verify(windowRequestedHeightSpy.valid);
++
++            mouseFlick(root, startDragX, startDragY, startDragX + deltaX, startDragY + deltaY, true, true, units.gu(.5), 10);
++
++            compare(windowRequestedWidthSpy.count, 1);
++            compare(fakeWindow.width, initialWindowWidth + fakeWindow.widthIncrement);
++            compare(windowRequestedHeightSpy.count, 1);
++            compare(fakeWindow.height, initialWindowHeight + fakeWindow.heightIncrement);
++        }
++
++        /*
++            Tests that when dragging a window border you cannot make it bigger than its maximum size
++         */
++        function test_maximumSize() {
++            fakeWindow.x = units.gu(1);
++            fakeWindow.y = units.gu(1);
++            fakeWindow.resizeAreaMinWidth = 1; // so it does not interfere with anything
++            fakeWindow.resizeAreaMinHeight = 1; // so it does not interfere with anything
++            fakeWindow.requestedWidth = units.gu(10);
++            fakeWindow.requestedHeight = units.gu(10);
++
++            fakeWindow.maximumWidth = units.gu(20);
++            fakeWindow.maximumHeight = units.gu(20);
++
++            // Our test window resizes instantly
++            compare(fakeWindow.width, fakeWindow.requestedWidth);
++            compare(fakeWindow.height, fakeWindow.requestedHeight);
++
++            var startDragX = fakeWindow.width + 1
++            var startDragY = fakeWindow.height + 1
++            var endDragX = (fakeWindow.maximumWidth * 2) + 1;
++            var endDragY = (fakeWindow.maximumHeight * 2) + 1;
++
++            mouseFlick(fakeWindow, startDragX, startDragY, endDragX, endDragY,
++                    true/*pressMouse*/, true/*releaseMouse*/, units.gu(.5)/*speed*/, 20/*iterations*/);
++
++            compare(fakeWindow.requestedWidth, fakeWindow.maximumWidth);
++            compare(fakeWindow.requestedHeight, fakeWindow.maximumHeight);
++        }
++
++        /*
++            Tests that when dragging a window border you cannot make it smaller than its minimum size
++         */
++        function test_minimumSize() {
++            fakeWindow.x = units.gu(1);
++            fakeWindow.y = units.gu(1);
++            fakeWindow.resizeAreaMinWidth = 1; // so it does not interfere with anything
++            fakeWindow.resizeAreaMinHeight = 1; // so it does not interfere with anything
++            fakeWindow.requestedWidth = units.gu(20);
++            fakeWindow.requestedHeight = units.gu(20);
++
++            fakeWindow.minimumWidth = units.gu(10);
++            fakeWindow.minimumHeight = units.gu(10);
++
++            // Our test window resizes instantly
++            compare(fakeWindow.width, fakeWindow.requestedWidth);
++            compare(fakeWindow.height, fakeWindow.requestedHeight);
++
++            var startDragX = fakeWindow.width + 1
++            var startDragY = fakeWindow.height + 1
++            var endDragX = (fakeWindow.minimumWidth * 0.5) + 1;
++            var endDragY = (fakeWindow.minimumHeight * 0.5) + 1;
++
++            mouseFlick(fakeWindow, startDragX, startDragY, endDragX, endDragY,
++                    true/*pressMouse*/, true/*releaseMouse*/, units.gu(.5)/*speed*/, 20/*iterations*/);
++
++            compare(fakeWindow.requestedWidth, fakeWindow.minimumWidth);
++            compare(fakeWindow.requestedHeight, fakeWindow.minimumHeight);
++        }
+     }
+ }