Unity 8

Merge lp:~nick-dedekind/unity8/lp1475678.surface-occlude into lp:unity8

lp1475678.surface-occlude
Merge into trunk

Proposed by Nick Dedekind on 2015-10-05

Status:

Superseded

Proposed branch:

lp:~nick-dedekind/unity8/lp1475678.surface-occlude

Merge into:

lp:unity8

Diff against target:

510 lines (+233/-35)

9 files modified

debian/control (+1/-1)
qml/Stages/DesktopStage.qml (+71/-3)
qml/Stages/PhoneStage.qml (+10/-3)
qml/Stages/TabletStage.qml (+8/-0)
tests/mocks/Unity/Application/MirSurface.cpp (+44/-17)
tests/mocks/Unity/Application/MirSurface.h (+14/-4)
tests/mocks/Unity/Application/MirSurfaceItem.cpp (+12/-2)
tests/mocks/Unity/Application/MirSurfaceItem.h (+1/-0)
tests/qmltests/Stages/tst_DesktopStage.qml (+72/-5)

To merge this branch:

bzr merge lp:~nick-dedekind/unity8/lp1475678.surface-occlude

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2015-10-27
Michał Sawicz			Needs Fixing on 2015-10-26
Michael Zanetti (community)			Abstain on 2015-10-21
Daniel d'Andrada (community)		2015-10-05	Needs Fixing on 2015-10-13
Review via email: mp+273427@code.launchpad.net

This proposal has been superseded by a proposal from 2015-10-27.

Commit message

Support server->client visibility change to stop rendering (lp:#1475678)

Description of the change

Support server->client visibility change to stop rendering (lp:#1475678)

* Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~nick-dedekind/qtmir/lp1475678.surface-occlude/+merge/273426
https://code.launchpad.net/~nick-dedekind/unity-api/lp1475678.surface-occlude/+merge/273425
https://code.launchpad.net/~nick-dedekind/qtubuntu/lp1475678.surface-occlude/+merge/273424

* Did you perform an exploratory manual test run of your code change and any related functionality?
* Did you make sure that your branch does not contain spurious tags?
* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
* If you changed the UI, has there been a design review?

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-06

1974. By Nick Dedekind on 2015-10-06: occlude on screen power

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

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

In qml/Stages/TabletStage.qml:

"""
+ // Hiding tiles when their progress is negative or reached the maximum
"""

A TODO item?

review: Needs Information

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-12

1975. By Nick Dedekind on 2015-10-12: update hide comment

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2015-10-12:

> In qml/Stages/TabletStage.qml:
>
> """
> + // Hiding tiles when their progress is negative or reached the maximum
> """
>
> A TODO item?

Yes. Fixed.

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

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

Shouldn't we do something for DesktopStage.qml as well? I quickly checked its code and it seems it doesn't set windows visibility at all.

Things to check:
- Minimized windows should have their MirSurfaces invisible/occluded.
- When a window is focused (on foreground, index 0) and maximized, the MirSurfaces of all others should be invisible/occluded

review: Needs Fixing

Revision history for this message

Michał Sawicz (saviq) wrote on 2015-10-13:

W dniu 13.10.2015 o 14:41, Daniel d'Andrada pisze:
> Things to check:
> - Minimized windows should have their MirSurfaces invisible/occluded.
> - When a window is focused (on foreground, index 0) and maximized, the MirSurfaces of all others should be invisible/occluded

And (maybe later) we should actually try and determine real visibility -
if a window is completely covered by others (we should probably exclude
windows with alpha from this), it should be made invisible/occluded, too.

Revision history for this message

Lukáš Tinkl (lukas-kde) wrote on 2015-10-13:

Left some inline comments; also:

> When a window is focused (on foreground, index 0) and maximized, the MirSurfaces of all others
> should be invisible/occluded

Just wondering what happens in multi monitor situations, should all the other windows/surfaces get occluded too in this case?

Revision history for this message

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

On 13/10/2015 10:32, Lukáš Tinkl wrote:
>> When a window is focused (on foreground, index 0) and maximized, the MirSurfaces of all others
>> >should be invisible/occluded
> Just wondering what happens in multi monitor situations, should all the other windows/surfaces get occluded too in this case?

Since multimonitor hasn't landed and this branch does not build on top
of it, it can't really address multimonitor issues here. Furthermore, on
the first iteration, windows will be shown all in a single screen (be it
the built-in display or an external monitor), so multimonitor doesn't
really affect occlusion scenarios right now.

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-13

1976. By Nick Dedekind on 2015-10-13: dekstop stage item visibility

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2015-10-13:

> Shouldn't we do something for DesktopStage.qml as well? I quickly checked its
> code and it seems it doesn't set windows visibility at all.
>
> Things to check:
> - Minimized windows should have their MirSurfaces invisible/occluded.
> - When a window is focused (on foreground, index 0) and maximized, the
> MirSurfaces of all others should be invisible/occluded

Added.

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

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

Could you please add a qml test to tst_DesktopStage to cover the "hide windows behind the maximized one" feature? Logic looks involved enough to warrant a test.

Revision history for this message

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

* Open 2 windows so that both are visible. Maximize one, the other will disappear before it's occluded.

* It breaks the alt+tab preview.

review: Needs Fixing

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-20

1977. By Nick Dedekind on 2015-10-20: fixed surface visibility

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

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

> * Open 2 windows so that both are visible. Maximize one, the other will
> disappear before it's occluded.
>
> * It breaks the alt+tab preview.

Both seem to be fixed now.

review: Abstain

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-22

1978. By Nick Dedekind on 2015-10-22: Only visible if in front of maximized application

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Michał Sawicz (saviq) on 2015-10-26:

review: Needs Fixing

lp:~nick-dedekind/unity8/lp1475678.surface-occlude updated on 2015-10-26

1979. By Nick Dedekind on 2015-10-26: merged with trunk
1980. By Nick Dedekind on 2015-10-26: bump libunity-api version

Revision history for this message

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

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

review: Needs Fixing (continuous-integration)

Unmerged revisions

1980. By Nick Dedekind on 2015-10-26: bump libunity-api version
1979. By Nick Dedekind on 2015-10-26: merged with trunk

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:

Mohammad Rakibul Hasan

Nick Dedekind

Unity Team

 === modified file 'debian/control'
 --- debian/control	2015-10-21 11:51:11 +0000
 +++ debian/control	2015-10-26 18:36:26 +0000
@@ -29,7 +29,7 @@
                 libqt5xmlpatterns5-dev,
                 libsystemsettings-dev,
                 libudev-dev,
--               libunity-api-dev (>= 7.101),
++               libunity-api-dev (>= 7.102),
                 libusermetricsoutput1-dev,
                 libxcb1-dev,
                 pkg-config,
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2015-10-19 14:27:57 +0000
 +++ qml/Stages/DesktopStage.qml	2015-10-26 18:36:26 +0000
@@ -65,6 +65,11 @@
              ApplicationManager.requestFocusApplication(appId)
+         }
++        onApplicationRemoved: {
++            if (priv.foregroundMaximizedAppId === appId) {
++                priv.foregroundMaximizedAppIdIndex = -1;
++            }
++        }
          onFocusRequested: {
              var appIndex = priv.indexOf(appId);
@@ -86,6 +91,17 @@
              var index = indexOf(focusedAppId);
              return index >= 0 && index < appRepeater.count ? appRepeater.itemAt(index) : null
+         }
++        readonly property string foregroundMaximizedAppId: {
++            if (foregroundMaximizedAppIdIndex == -1) {
++                return "";
++            }
++            var app = ApplicationManager.get(foregroundMaximizedAppIdIndex);
++            if (app) {
++                return app.appId;
++            }
++            return "";
++        }
++        property int foregroundMaximizedAppIdIndex: -1
          function indexOf(appId) {
              for (var i = 0; i < ApplicationManager.count; i++) {
@@ -132,6 +148,7 @@
              delegate: FocusScope {
                  id: appDelegate
++                objectName: "stageDelegate_" + model.appId
                  z: ApplicationManager.count - index
                  y: units.gu(3)
                  width: units.gu(60)
@@ -141,12 +158,47 @@
                  property bool maximized: false
                  property bool minimized: false
++                property bool visuallyMaximized: false
++                property bool visuallyMinimized: false
++
                  onFocusChanged: {
                      if (focus && ApplicationManager.focusedApplicationId !== model.appId) {
                          ApplicationManager.focusApplication(model.appId);
+                     }
+                 }
++                onZChanged: updateMaximized()
++                onVisuallyMaximizedChanged: updateMaximized()
++                Connections {
++                    target: priv
++                    onForegroundMaximizedAppIdIndexChanged: updateMaximized()
++                }
++
++                property bool connectMaxEnabled: true
++                function updateMaximized() {
++                    if (!connectMaxEnabled) return;
++                    connectMaxEnabled = false;
++
++                    // work out if this is the top maximized app.
++                    if (visuallyMaximized) {
++                        if (priv.foregroundMaximizedAppId === model.appId) {
++                            priv.foregroundMaximizedAppIdIndex = index;
++                        }
++                        else if (priv.foregroundMaximizedAppIdIndex == -1 ||
++                                 (index >= 0 && index <= priv.foregroundMaximizedAppIdIndex)) {
++                            priv.foregroundMaximizedAppIdIndex = index;
++                        }
++                    } else if (priv.foregroundMaximizedAppId === model.appId) {
++                        priv.foregroundMaximizedAppIdIndex = -1;
++                    }
++
++                    connectMaxEnabled = true;
++                }
++
++                visible: !visuallyMinimized &&
++                         (priv.foregroundMaximizedAppIdIndex === -1 || priv.foregroundMaximizedAppIdIndex >= index) ||
++                         (spread.focus && index === spread.highlightedIndex)
++
                  Binding {
                      target: ApplicationManager.get(index)
                      property: "requestedState"
@@ -186,9 +238,25 @@
+                 ]
                  transitions: [
                      Transition {
--                        from: "maximized,minimized,normal,"
--                        to: "maximized,minimized,normal,"
--                        PropertyAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale" }
++                        to: "normal"
++                        PropertyAction { target: appDelegate; properties: "visuallyMinimized,visuallyMaximized"; value: false }
++                        PropertyAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale," }
++                    },
++                    Transition {
++                        to: "maximized"
++                        SequentialAnimation {
++                            PropertyAction { target: appDelegate; property: "visuallyMinimized"; value: false }
++                            PropertyAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale" }
++                            PropertyAction { target: appDelegate; property: "visuallyMaximized"; value: true }
++                        }
++                    },
++                    Transition {
++                        to: "minimized"
++                        SequentialAnimation {
++                            PropertyAction { target: appDelegate; property: "visuallyMaximized"; value: false }
++                            PropertyAnimation { target: appDelegate; properties: "x,y,opacity,width,height,scale" }
++                            PropertyAction { target: appDelegate; property: "visuallyMinimized"; value: true }
++                        }
                      },
                      Transition {
                          from: ""
 === modified file 'qml/Stages/PhoneStage.qml'
 --- qml/Stages/PhoneStage.qml	2015-09-21 13:37:47 +0000
 +++ qml/Stages/PhoneStage.qml	2015-10-26 18:36:26 +0000
@@ -20,6 +20,7 @@
  import Unity.Application 0.1
  import Unity.Session 0.1
  import Utils 0.1
++import Powerd 0.1
  import "../Components"
  Rectangle {
@@ -531,9 +532,15 @@
                          return progress;
+                     }
--                    // Hiding tiles when their progress is negative or reached the maximum
--                    visible: (progress >= 0 && progress < 1.7)
--                            || (isDash && priv.focusedAppDelegateIsDislocated)
++                    // Hide tile when progress is such that it will be off screen.
++                    property bool occluded: {
++                        if (spreadView.active && (progress >= 0 && progress < 1.7)) return false;
++                        if (!spreadView.active && isFocused) return false;
++                        return true;
++                    }
++
++                    visible: Powerd.status == Powerd.On &&
++                             (!occluded || (isDash && priv.focusedAppDelegateIsDislocated))
                      shellOrientationAngle: root.shellOrientationAngle
 === modified file 'qml/Stages/TabletStage.qml'
 --- qml/Stages/TabletStage.qml	2015-08-03 13:47:44 +0000
 +++ qml/Stages/TabletStage.qml	2015-10-26 18:36:26 +0000
@@ -676,6 +676,14 @@
                          return tileProgress;
+                     }
++                    // TODO: Hiding tile when progress is such that it will be off screen.
++                    property bool occluded: {
++                        if (spreadView.active) return false;
++                        else if (isFocused) return false;
++                        return true;
++                    }
++                    visible: !occluded
++
                      animatedProgress: {
                          if (spreadView.phase == 0 && (spreadTile.active || spreadView.nextInStack == index)) {
                              if (progress < spreadView.positionMarker1) {
 === modified file 'tests/mocks/Unity/Application/MirSurface.cpp'
 --- tests/mocks/Unity/Application/MirSurface.cpp	2015-09-25 12:13:13 +0000
 +++ tests/mocks/Unity/Application/MirSurface.cpp	2015-10-26 18:36:26 +0000
@@ -31,7 +31,7 @@
      , m_screenshotUrl(screenshot)
      , m_qmlFilePath(qmlFilePath)
      , m_live(true)
--    , m_viewCount(0)
++    , m_visible(true)
      , m_activeFocus(false)
      , m_width(-1)
      , m_height(-1)
@@ -73,6 +73,11 @@
      return m_live;
+ }
++bool MirSurface::visible() const
++{
++    return m_visible;
++}
++
  void MirSurface::setLive(bool live)
+ {
  //    qDebug().nospace() << "MirSurface::setLive("<<live<<") " << name();
@@ -82,7 +87,7 @@
      m_live = live;
      Q_EMIT liveChanged(live);
--    if (!m_live && m_viewCount == 0) {
++    if (!m_live && m_views.count() == 0) {
          deleteLater();
+     }
+ }
@@ -120,27 +125,49 @@
      Q_EMIT orientationAngleChanged(angle);
+ }
--void MirSurface::incrementViewCount()
++
++
++void MirSurface::registerView(qintptr viewId)
+ {
--    ++m_viewCount;
--//    qDebug().nospace() << "MirSurface::incrementViewCount() viewCount(after)=" << m_viewCount << " " << name();
++    m_views.insert(viewId, MirSurface::View{false});
++//    qDebug().nospace() << "MirSurface[" << name() << "]::registerView(" << viewId << ")"
++//                                      << " after=" << m_views.count();
+ }
--void MirSurface::decrementViewCount()
++void MirSurface::unregisterView(qintptr viewId)
+ {
--    --m_viewCount;
--//    qDebug().nospace() << "MirSurface::decrementViewCount() viewCount(after)=" << m_viewCount << " " << name();
--
--    Q_ASSERT(m_viewCount >= 0);
--
--    if (!m_live && m_viewCount == 0) {
++//    qDebug().nospace() << "MirSurface[" << name() << "]::unregisterView(" << viewId << ")"
++//                                      << " after=" << m_views.count() << " live=" << m_live;
++    m_views.remove(viewId);
++    if (!m_live && m_views.count() == 0) {
          deleteLater();
+     }
--}
--
--int MirSurface::viewCount() const
--{
--    return m_viewCount;
++    updateVisibility();
++}
++
++void MirSurface::setViewVisibility(qintptr viewId, bool visible)
++{
++    if (!m_views.contains(viewId)) return;
++
++    m_views[viewId].visible = visible;
++    updateVisibility();
++}
++
++void MirSurface::updateVisibility()
++{
++    bool newVisible = false;
++    QHashIterator<qintptr, View> i(m_views);
++    while (i.hasNext()) {
++        i.next();
++        newVisible |= i.value().visible;
++    }
++
++    if (newVisible != visible()) {
++//        qDebug().nospace() << "MirSurface[" << name() << "]::updateVisibility(" << newVisible << ")";
++
++        m_visible = newVisible;
++        Q_EMIT visibleChanged(m_visible);
++    }
+ }
  bool MirSurface::activeFocus() const
 === modified file 'tests/mocks/Unity/Application/MirSurface.h'
 --- tests/mocks/Unity/Application/MirSurface.h	2015-09-02 10:35:16 +0000
 +++ tests/mocks/Unity/Application/MirSurface.h	2015-10-26 18:36:26 +0000
@@ -19,6 +19,7 @@
  #include <QObject>
  #include <QUrl>
++#include <QHash>
  // unity-api
  #include <unity/shell/application/MirSurfaceInterface.h>
@@ -58,6 +59,8 @@
      bool live() const override;
++    bool visible() const override;
++
      Mir::OrientationAngle orientationAngle() const override;
      void setOrientationAngle(Mir::OrientationAngle) override;
@@ -66,9 +69,10 @@
      Q_INVOKABLE void setLive(bool live);
--    void incrementViewCount();
--    void decrementViewCount();
--    int viewCount() const;
++    void registerView(qintptr viewId);
++    void unregisterView(qintptr viewId);
++    void setViewVisibility(qintptr viewId, bool visible);
++    int viewCount() const { return m_views.count(); }
      int width() const;
      int height() const;
@@ -97,6 +101,8 @@
      void activeFocusChanged(bool);
  private:
++    void updateVisibility();
++
      const QString m_name;
      const Mir::Type m_type;
      Mir::State m_state;
@@ -104,10 +110,14 @@
      QUrl m_screenshotUrl;
      QUrl m_qmlFilePath;
      bool m_live;
--    int m_viewCount;
++    bool m_visible;
      bool m_activeFocus;
      int m_width;
      int m_height;
++    struct View {
++        bool visible;
++    };
++    QHash<qintptr, View> m_views;
  };
  #endif // MOCK_MIR_SURFACE_H
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.cpp'
 --- tests/mocks/Unity/Application/MirSurfaceItem.cpp	2015-09-25 12:13:13 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.cpp	2015-10-26 18:36:26 +0000
@@ -44,6 +44,8 @@
          Qt::ExtraButton5 | Qt::ExtraButton6 | Qt::ExtraButton7 | Qt::ExtraButton8 |
          Qt::ExtraButton9 | Qt::ExtraButton10 | Qt::ExtraButton11 |
          Qt::ExtraButton12 | Qt::ExtraButton13);
++
++    connect(this, &QQuickItem::visibleChanged, this, &MirSurfaceItem::updateMirSurfaceVisibility);
+ }
  MirSurfaceItem::~MirSurfaceItem()
@@ -194,17 +196,18 @@
          m_qmlContentComponent = nullptr;
          disconnect(m_qmlSurface, nullptr, this, nullptr);
--        m_qmlSurface->decrementViewCount();
++        m_qmlSurface->unregisterView((qintptr)this);
+     }
      m_qmlSurface = static_cast<MirSurface*>(surface);
      if (m_qmlSurface) {
--        m_qmlSurface->incrementViewCount();
++        m_qmlSurface->registerView((qintptr)this);
          m_qmlSurface->setActiveFocus(hasActiveFocus());
          updateSurfaceSize();
++        updateMirSurfaceVisibility();
          connect(m_qmlSurface, &MirSurface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
          connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);
@@ -253,6 +256,13 @@
+     }
+ }
++void MirSurfaceItem::updateMirSurfaceVisibility()
++{
++    if (!m_qmlSurface) return;
++
++    m_qmlSurface->setViewVisibility((qintptr)this, isVisible());
++}
++
  void MirSurfaceItem::setConsumesInput(bool value)
+ {
      if (m_consumesInput != value) {
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.h'
 --- tests/mocks/Unity/Application/MirSurfaceItem.h	2015-09-19 07:37:52 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.h	2015-10-26 18:36:26 +0000
@@ -87,6 +87,7 @@
  private Q_SLOTS:
      void onComponentStatusChanged(QQmlComponent::Status status);
      void updateScreenshot(QUrl screenshot);
++    void updateMirSurfaceVisibility();
  private:
      void createQmlContentItem();
 === modified file 'tests/qmltests/Stages/tst_DesktopStage.qml'
 --- tests/qmltests/Stages/tst_DesktopStage.qml	2015-09-17 12:25:29 +0000
 +++ tests/qmltests/Stages/tst_DesktopStage.qml	2015-10-26 18:36:26 +0000
@@ -35,12 +35,15 @@
          value: false
+     }
--    Component.onCompleted: {
++    Component.onCompleted: resetGeometry()
++
++    function resetGeometry() {
          // ensures apps which are tested decorations are in view.
          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))
+         }
+     }
@@ -110,14 +113,14 @@
              desktopStageLoader.active = true;
              tryCompare(desktopStageLoader, "status", Loader.Ready);
++            root.resetGeometry();
+         }
          function killAllRunningApps() {
--            while (ApplicationManager.count > 1) {
--                var appIndex = ApplicationManager.get(0).appId == "unity8-dash" ? 1 : 0
--                ApplicationManager.stopApplication(ApplicationManager.get(appIndex).appId);
++            while (ApplicationManager.count > 0) {
++                ApplicationManager.stopApplication(ApplicationManager.get(0).appId);
+             }
--            compare(ApplicationManager.count, 1)
++            compare(ApplicationManager.count, 0)
+         }
          function waitUntilAppSurfaceShowsUp(appId) {
@@ -210,5 +213,69 @@
              tap(toAppDecoration);
              tryCompare(ApplicationManager.findApplication(data.apps[data.focusTo]).session.surface, "activeFocus", true);
+         }
++
++        function test_minimizeApplicationHidesSurface(data) {
++            var dashApp = startApplication("unity8-dash");
++
++            var dashDelegate = findChild(desktopStage, "stageDelegate_unity8-dash");
++            verify(dashDelegate);
++
++            dashDelegate.minimize();
++            tryCompare(dashApp.session.surface, "visible", false);
++        }
++
++        function test_maximizeApplicationHidesSurfacesBehindIt(data) {
++            var dashApp = startApplication("unity8-dash");
++            var dialerApp = startApplication("dialer-app");
++            var cameraApp = startApplication("camera-app");
++
++            var dashDelegate = findChild(desktopStage, "stageDelegate_unity8-dash");
++            verify(dashDelegate);
++            var dialerDelegate = findChild(desktopStage, "stageDelegate_dialer-app");
++            verify(dialerDelegate);
++            var cameraDelegate = findChild(desktopStage, "stageDelegate_camera-app");
++            verify(cameraDelegate);
++
++            dialerDelegate.maximize();
++            tryCompare(dialerDelegate, "visuallyMaximized", true);
++
++            tryCompare(dashApp.session.surface, "visible", false);
++            compare(cameraApp.session.surface.visible, true);
++
++            dialerDelegate.unmaximize();
++            compare(dashApp.session.surface.visible, true);
++            compare(cameraApp.session.surface.visible, true);
++        }
++
++        function test_applicationsBecomeVisibleWhenOccludingAppRemoved(data) {
++            var dashApp = startApplication("unity8-dash");
++            var dialerApp = startApplication("dialer-app");
++            var cameraApp = startApplication("camera-app");
++            var galleryApp = startApplication("gallery-app");
++
++            var dashDelegate = findChild(desktopStage, "stageDelegate_unity8-dash");
++            verify(dashDelegate);
++            var dialerDelegate = findChild(desktopStage, "stageDelegate_dialer-app");
++            verify(dialerDelegate);
++            var cameraDelegate = findChild(desktopStage, "stageDelegate_camera-app");
++            verify(cameraDelegate);
++            var galleryDelegate = findChild(desktopStage, "stageDelegate_gallery-app");
++            verify(galleryDelegate);
++
++            dialerDelegate.maximize();
++            galleryDelegate.maximize();
++            tryCompare(dialerDelegate, "visuallyMaximized", true);
++            tryCompare(galleryDelegate, "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(dialerApp.session.surface, "visible", true);
++            tryCompare(dashApp.session.surface, "visible", false); // still occluded by maximised dialer
++        }
+     }
+ }