Merge lp:~mzanetti/unity8/screens-workspaces-switcher into lp:unity8

[Michael Zanetti]

screens and workspaces switcher

WIP

related branches:
https://code.launchpad.net/~nick-dedekind/unity8/multi-monitor/+merge/314835
https://code.launchpad.net/~nick-dedekind/qtmir/multi-monitor/+merge/314836
https://code.launchpad.net/~nick-dedekind/unity-api/multi-monitor/+merge/314837

[lp:~mzanetti/unity8/screens-workspaces-switcher]

2763. By Michael Zanetti on 2017-01-16

split it up

2764. By Michael Zanetti on 2017-01-16

merge prereq

2765. By Michael Zanetti on 2017-01-16

improve previews

2766. By Michael Zanetti on 2017-01-16

merge prereq

2767. By Michael Zanetti on 2017-01-23

merge prereq

2768. By Michael Zanetti on 2017-01-23

add hover item to screens

2769. By Michael Zanetti on 2017-01-23

drop empty line

2770. By Michael Zanetti on 2017-01-23

merge prereq

2771. By Michael Zanetti on 2017-01-23

merge prereq

2772. By Michael Zanetti on 2017-01-23

activate the other screen on timeout

2773. By Michael Zanetti on 2017-01-23

add icon, adjust visuals

2774. By Michael Zanetti on 2017-02-03

make workspaces a listview

2775. By Michael Zanetti on 2017-02-03

merge prereq

2776. By Michael Zanetti on 2017-02-03

make it a listview, update to latest api

2777. By Michael Zanetti on 2017-02-07

some more work on the workspace preview spread

2778. By Michael Zanetti on 2017-02-09

add drag and drop wor workspaces between screens

2779. By Michael Zanetti on 2017-02-10

play with the size

2780. By Michael Zanetti on 2017-02-10

merge prereq

2781. By Michael Zanetti on 2017-02-13

add scrolling areas

2782. By Michael Zanetti on 2017-02-13

merge trunk

2783. By Michael Zanetti on 2017-02-14

fix imports

2784. By Michael Zanetti on 2017-02-20

add support for dragging apps out of the spread

2785. By Michael Zanetti on 2017-02-20

improve dragging and hover scrolling

2786. By Michael Zanetti on 2017-02-20

optimize it a little

2787. By Michael Zanetti on 2017-02-23

merge new prereq

2788. By Michael Zanetti on 2017-02-23

merge new prereq

2789. By Michael Zanetti on 2017-02-23

make use of actual workspace model instead of dummy ListModels

2790. By Michael Zanetti on 2017-02-23

properly create and destroy workspaces

2791. By Michael Zanetti on 2017-03-02

merge prereq

2792. By Michael Zanetti on 2017-03-02

merge prereq

2793. By Michael Zanetti on 2017-03-06

update to latest backend code

2794. By Michael Zanetti on 2017-03-07

merge prereq

2795. By Michael Zanetti on 2017-03-08

merge prereq

2796. By Michael Zanetti on 2017-03-08

bump u-a-l version requirement

2797. By Michael Zanetti on 2017-03-08

merge prereq

2798. By Michael Zanetti on 2017-03-08

use a toplevelwindowmodel per workspace

2799. By Michael Zanetti on 2017-03-08

merge prereq

2800. By Michael Zanetti on 2017-03-09

merge prereq

2801. By Michael Zanetti on 2017-03-09

some improvements

2802. By Michael Zanetti on 2017-03-09

some more fixes

2803. By Michael Zanetti on 2017-03-09

add close button on hover

2804. By Michael Zanetti on 2017-03-09

fix workspace preview scaling

2805. By Michael Zanetti on 2017-03-10

add outputTypeName to Screen

2806. By Michael Zanetti on 2017-03-13

merge prereq

2807. By Michael Zanetti on 2017-03-13

minor tweaks

2808. By Michael Zanetti on 2017-03-14

merge prereq

2809. By Michael Zanetti on 2017-03-14

finalize drag and drop for apps to another workspace

(not working yet for some reason, likely in the backend stuff that's to be debugged still)

2810. By Michael Zanetti on 2017-03-14

fix drag and drop of applications

2811. By Michael Zanetti on 2017-03-14

highlight active workspace

2812. By Michael Zanetti on 2017-03-15

add feature to drop to the left/right of a workspace

2813. By Michael Zanetti on 2017-03-15

merge prereq

2814. By Michael Zanetti on 2017-03-15

add text to drop targets

2815. By Michael Zanetti on 2017-03-15

merge prereq

2816. By Michael Zanetti on 2017-03-16

merge prereq

2817. By Michael Zanetti on 2017-03-16

add missing graphics file

2818. By Michael Zanetti on 2017-03-16

cancel dnd operation properly

2819. By Michael Zanetti on 2017-03-16

use correct graphic

2820. By Michael Zanetti on 2017-03-16

merge prereq

2821. By Michael Zanetti on 2017-03-16

don't apply transitions if a delegate is created while we're in spread

2822. By Michael Zanetti on 2017-03-16

improve listview animations and handling

Unmerged revisions

2822. By Michael Zanetti on 2017-03-16

improve listview animations and handling

2821. By Michael Zanetti on 2017-03-16

don't apply transitions if a delegate is created while we're in spread

2820. By Michael Zanetti on 2017-03-16

merge prereq

2819. By Michael Zanetti on 2017-03-16

use correct graphic

2818. By Michael Zanetti on 2017-03-16

cancel dnd operation properly

2817. By Michael Zanetti on 2017-03-16

add missing graphics file

2816. By Michael Zanetti on 2017-03-16

merge prereq

2815. By Michael Zanetti on 2017-03-15

merge prereq

2814. By Michael Zanetti on 2017-03-15

add text to drop targets

2813. By Michael Zanetti on 2017-03-15

merge prereq

=== modified file 'plugins/Cursor/CMakeLists.txt'
--- plugins/Cursor/CMakeLists.txt	2016-11-28 09:57:06 +0000
+++ plugins/Cursor/CMakeLists.txt	2017-01-16 11:35:19 +0000
@@ -15,6 +15,7 @@
     CursorImageInfo.cpp
     CursorImageProvider.cpp
     MousePointer.cpp
+    InputDispatcherFilter.cpp
     # We need to run moc on this header
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
     )

=== added file 'plugins/Cursor/InputDispatcherFilter.cpp'
--- plugins/Cursor/InputDispatcherFilter.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/InputDispatcherFilter.cpp	2017-01-16 11:35:19 +0000
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "InputDispatcherFilter.h"
+#include "MousePointer.h"
+
+#include <QEvent>
+#include <QGuiApplication>
+#include <QScreen>
+#include <qpa/qplatformnativeinterface.h>
+#include <qpa/qplatformscreen.h>
+
+InputDispatcherFilter *InputDispatcherFilter::instance()
+{
+    static InputDispatcherFilter filter;
+    return &filter;
+}
+
+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)
+    : QObject(parent)
+{
+    QPlatformNativeInterface *ni = QGuiApplication::platformNativeInterface();
+    m_inputDispatcher = static_cast<QObject*>(ni->nativeResourceForIntegration("InputDispatcher"));
+    if (m_inputDispatcher) {
+        m_inputDispatcher->installEventFilter(this);
+    }
+}
+
+void InputDispatcherFilter::registerPointer(MousePointer *pointer)
+{
+    // allow first registered pointer to be visible.
+    pointer->setVisible(m_pointers.count() == 0);
+
+    m_pointers.insert(pointer);
+    connect(pointer, &MousePointer::mouseMoved, this, [this, pointer]() {
+        Q_FOREACH(auto p, m_pointers) {
+            p->setVisible(p == pointer);
+        }
+    });
+}
+
+void InputDispatcherFilter::unregisterPointer(MousePointer *pointer)
+{
+    m_pointers.remove(pointer);
+    disconnect(pointer, &MousePointer::mouseMoved, this, 0);
+}
+
+void InputDispatcherFilter::setPosition(const QPointF &pos)
+{
+    mousePosition = pos;
+}
+
+bool InputDispatcherFilter::eventFilter(QObject *o, QEvent *e)
+{
+    if (o != m_inputDispatcher) return false;
+
+    switch (e->type()) {
+        case QEvent::MouseMove:
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        {
+            // FIXME - removed all input filtering for now - this was for extended display
+            return false;
+
+//            QMouseEvent* me = static_cast<QMouseEvent*>(e);
+
+//            // Local position gives relative change of mouse pointer.
+//            QPointF localPos = me->localPos();
+//            QPointF globalPos = me->screenPos();
+
+//            // Adjust the position
+//            QPointF oldPos(mousePosition.isNull() ? globalPos : mousePosition);
+//            QPointF newPos = adjustedPositionForMovement(oldPos, localPos);
+
+//            QScreen* currentScreen = screenAt(newPos);
+//            if (currentScreen) {
+//                QRect screenRect = currentScreen->geometry();
+//                qreal unadjustedX = (oldPos + localPos).x();
+//                if (unadjustedX < screenRect.left()) {
+//                    Q_EMIT pushedLeftBoundary(currentScreen, qAbs(unadjustedX - screenRect.left()), me->buttons());
+//                } else if (unadjustedX > screenRect.right()) {
+//                    Q_EMIT pushedRightBoundary(currentScreen, qAbs(unadjustedX - screenRect.right()), me->buttons());
+//                }
+//            }
+
+//            // Send the event
+//            QMouseEvent eCopy(me->type(), me->localPos(), newPos, me->button(), me->buttons(), me->modifiers());
+//            eCopy.setTimestamp(me->timestamp());
+//            o->event(&eCopy);
+//            return true;
+        }
+        default:
+            break;
+    }
+    return false;
+}
+
+QPointF InputDispatcherFilter::adjustedPositionForMovement(const QPointF &pt, const QPointF &movement) const
+{
+    QPointF adjusted = pt + movement;
+
+    auto screen = screenAt(adjusted); // first check if our move was to a valid screen.
+    if (screen) {
+        return adjusted;
+    } else if ((screen = screenAt(pt))) { // then check if our old position was valid
+        QRectF screenBounds = screen->geometry();
+        // bound the new position to the old screen geometry
+        adjusted.rx() = qMax(screenBounds.left(), qMin(adjusted.x(), screenBounds.right()-1));
+        adjusted.ry() = qMax(screenBounds.top(), qMin(adjusted.y(), screenBounds.bottom()-1));
+    } else {
+        auto screens = QGuiApplication::screens();
+
+        // center of first screen with a pointer.
+        Q_FOREACH(QScreen* screen, screens) {
+            Q_FOREACH(MousePointer* pointer, m_pointers) {
+                if (pointer->screen() == screen) {
+                    return screen->geometry().center();
+                }
+            }
+        }
+    }
+    return adjusted;
+}
+
+QScreen *InputDispatcherFilter::screenAt(const QPointF &pt) const
+{
+    Q_FOREACH(MousePointer* pointer, m_pointers) {
+        QScreen* screen = pointer->screen();
+        if (screen && screen->geometry().contains(pt.toPoint()))
+            return screen;
+    }
+    return nullptr;
+}

=== added file 'plugins/Cursor/InputDispatcherFilter.h'
--- plugins/Cursor/InputDispatcherFilter.h	1970-01-01 00:00:00 +0000
+++ plugins/Cursor/InputDispatcherFilter.h	2017-01-16 11:35:19 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INPUTDISPATCHERFILTER_H
+#define INPUTDISPATCHERFILTER_H
+
+#include <QObject>
+#include <QPointF>
+#include <QSet>
+
+class MousePointer;
+class QScreen;
+
+class InputDispatcherFilter : public QObject
+{
+    Q_OBJECT
+public:
+    static InputDispatcherFilter *instance();
+
+    void registerPointer(MousePointer* pointer);
+
+    void unregisterPointer(MousePointer* pointer);
+
+    void setPosition(const QPointF &pos);
+
+Q_SIGNALS:
+    void pushedLeftBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedRightBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+
+protected:
+    InputDispatcherFilter(QObject* parent = nullptr);
+
+    bool eventFilter(QObject *o, QEvent *e) override;
+
+    QPointF adjustedPositionForMovement(const QPointF& pt, const QPointF& movement) const;
+    QScreen* screenAt(const QPointF& pt) const;
+
+private:
+    QObject* m_inputDispatcher;
+    QSet<MousePointer*> m_pointers;
+    QPointF mousePosition;
+};
+
+#endif // INPUTDISPATCHERFILTER_H

=== modified file 'plugins/Cursor/MousePointer.cpp'
--- plugins/Cursor/MousePointer.cpp	2016-09-07 08:36:59 +0000
+++ plugins/Cursor/MousePointer.cpp	2017-01-16 11:35:19 +0000
@@ -16,84 +16,57 @@
 
 #include "MousePointer.h"
 #include "CursorImageProvider.h"
+#include "InputDispatcherFilter.h"
+
+#include <QQuickWindow>
 
 // Unity API
 #include <unity/shell/application/MirPlatformCursor.h>
 
-#include <QQuickWindow>
-#include <QGuiApplication>
-#include <QtMath>
-
-#include <qpa/qwindowsysteminterface.h>
-
 MousePointer::MousePointer(QQuickItem *parent)
     : MirMousePointerInterface(parent)
     , m_cursorName(QStringLiteral("left_ptr"))
     , m_themeName(QStringLiteral("default"))
 {
-}
-
-void MousePointer::handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
-        Qt::KeyboardModifiers modifiers)
-{
-    if (!parentItem()) {
-        return;
-    }
-
-    if (!movement.isNull()) {
+    InputDispatcherFilter::instance()->registerPointer(this);
+
+    auto mouseMovedFunc = [this]() {
+        if (!isEnabled() || !window()) return;
+        QPointF globalPosition =  mapToItem(nullptr, QPointF(0, 0));
+        InputDispatcherFilter::instance()->setPosition(globalPosition);
         Q_EMIT mouseMoved();
-    }
-
-    m_accumulatedMovement += movement;
-    // don't apply the fractional part
-    QPointF appliedMovement(int(m_accumulatedMovement.x()), int(m_accumulatedMovement.y()));
-    m_accumulatedMovement -= appliedMovement;
-
-    qreal newX = x() + appliedMovement.x();
-    qreal newY = y() + appliedMovement.y();
-    const qreal sceneWidth = parentItem()->width();
-    const qreal sceneHeight = parentItem()->height();
-
-    if (newX <= 0 && newY < m_topBoundaryOffset) { // top left corner
-        const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-m_topBoundaryOffset, 2));
-        Q_EMIT pushedTopLeftCorner(qAbs(distance), buttons);
-        m_pushing = true;
-    } else if (newX >= sceneWidth-1 && newY < m_topBoundaryOffset) { // top right corner
-        const auto distance = qSqrt(qPow(newX-sceneWidth, 2) + qPow(newY-m_topBoundaryOffset, 2));
-        Q_EMIT pushedTopRightCorner(qAbs(distance), buttons);
-        m_pushing = true;
-    } else if (newX < 0 && newY >= sceneHeight-1) { // bottom left corner
-        const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-sceneHeight, 2));
-        Q_EMIT pushedBottomLeftCorner(qAbs(distance), buttons);
-        m_pushing = true;
-    } else if (newX >= sceneWidth-1 && newY >= sceneHeight-1) { // bottom right corner
-        const auto distance = qSqrt(qPow(newX-sceneWidth, 2) + qPow(newY-sceneHeight, 2));
-        Q_EMIT pushedBottomRightCorner(qAbs(distance), buttons);
-        m_pushing = true;
-    } else if (newX < 0) { // left edge
-        Q_EMIT pushedLeftBoundary(qAbs(newX), buttons);
-        m_pushing = true;
-    } else if (newX >= sceneWidth) { // right edge
-        Q_EMIT pushedRightBoundary(newX - (sceneWidth - 1), buttons);
-        m_pushing = true;
-    } else if (newY < m_topBoundaryOffset) { // top edge
-        Q_EMIT pushedTopBoundary(qAbs(newY - m_topBoundaryOffset), buttons);
-        m_pushing = true;
-    } else if (Q_LIKELY(newX > 0 && newX < sceneWidth-1 && newY > 0 && newY < sceneHeight-1)) { // normal pos, not pushing
-        if (m_pushing) {
-            Q_EMIT pushStopped();
-            m_pushing = false;
-        }
-    }
-
-    applyItemConfinement(newX, newY);
-
-    setX(qBound(0.0, newX, sceneWidth - 1));
-    setY(qBound(0.0, newY, sceneHeight - 1));
-
-    QPointF scenePosition = mapToItem(nullptr, QPointF(0, 0));
-    QWindowSystemInterface::handleMouseEvent(window(), timestamp, scenePosition /*local*/, scenePosition /*global*/,
-        buttons, modifiers);
+    };
+    connect(this, &QQuickItem::xChanged, this, mouseMovedFunc);
+    connect(this, &QQuickItem::yChanged, this, mouseMovedFunc);
+
+    connect(this, &QQuickItem::enabledChanged, this, [this]() {
+        if (!isEnabled()) setVisible(false);
+    });
+
+    connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedLeftBoundary,
+            this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {
+        if (window() && window()->screen() == screen) {
+            Q_EMIT pushedLeftBoundary(amount, buttons);
+        }
+    });
+
+    connect(InputDispatcherFilter::instance(), &InputDispatcherFilter::pushedRightBoundary,
+            this, [this](QScreen* screen, qreal amount, Qt::MouseButtons buttons) {
+        if (window() && window()->screen() == screen) {
+            Q_EMIT pushedRightBoundary(amount, buttons);
+        }
+    });
+}
+
+MousePointer::~MousePointer()
+{
+    registerScreen(nullptr);
+    InputDispatcherFilter::instance()->unregisterPointer(this);
+}
+
+void MousePointer::handleMouseEvent(ulong /*timestamp*/, QPointF /*movement*/, Qt::MouseButtons /*buttons*/,
+        Qt::KeyboardModifiers /*modifiers*/)
+{
 }
 
 void MousePointer::applyItemConfinement(qreal &newX, qreal &newY)
@@ -121,15 +94,8 @@
     }
 }
 
-void MousePointer::handleWheelEvent(ulong timestamp, QPoint angleDelta, Qt::KeyboardModifiers modifiers)
+void MousePointer::handleWheelEvent(ulong /*timestamp*/, QPoint /*angleDelta*/, Qt::KeyboardModifiers /*modifiers*/)
 {
-    if (!parentItem()) {
-        return;
-    }
-
-    QPointF scenePosition = mapToItem(nullptr, QPointF(0, 0));
-    QWindowSystemInterface::handleWheelEvent(window(), timestamp, scenePosition /* local */, scenePosition /* global */,
-            QPoint() /* pixelDelta */, angleDelta, modifiers, Qt::ScrollUpdate);
 }
 
 int MousePointer::topBoundaryOffset() const
@@ -182,7 +148,7 @@
     if (m_registeredScreen) {
         auto previousCursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());
         if (previousCursor) {
-            previousCursor->setMousePointer(nullptr);
+            previousCursor->unregisterMousePointer(this);
         } else {
             qCritical("QPlatformCursor is not a MirPlatformCursor! Cursor module only works in a Mir server.");
         }
@@ -193,7 +159,7 @@
     if (m_registeredScreen) {
         auto cursor = dynamic_cast<MirPlatformCursor*>(m_registeredScreen->handle()->cursor());
         if (cursor) {
-            cursor->setMousePointer(this);
+            cursor->registerMousePointer(this);
         } else {
             qCritical("QPlaformCursor is not a MirPlatformCursor! Cursor module only works in Mir.");
         }
@@ -233,3 +199,4 @@
         Q_EMIT confiningItemChanged();
     }
 }
+

=== modified file 'plugins/Cursor/MousePointer.h'
--- plugins/Cursor/MousePointer.h	2016-09-07 08:36:59 +0000
+++ plugins/Cursor/MousePointer.h	2017-01-16 11:35:19 +0000
@@ -31,6 +31,7 @@
     Q_PROPERTY(int topBoundaryOffset READ topBoundaryOffset WRITE setTopBoundaryOffset NOTIFY topBoundaryOffsetChanged)
 public:
     MousePointer(QQuickItem *parent = nullptr);
+    ~MousePointer();
 
     void setCursorName(const QString &qtCursorName) override;
     QString cursorName() const override { return m_cursorName; }
@@ -46,6 +47,8 @@
     int topBoundaryOffset() const;
     void setTopBoundaryOffset(int topBoundaryOffset);
 
+    QScreen* screen() const { return m_registeredScreen; }
+
 public Q_SLOTS:
     void handleMouseEvent(ulong timestamp, QPointF movement, Qt::MouseButtons buttons,
             Qt::KeyboardModifiers modifiers) override;
@@ -90,3 +93,4 @@
 };
 
 #endif // MOUSEPOINTER_H
+

=== modified file 'plugins/UInput/plugin.cpp'
--- plugins/UInput/plugin.cpp	2015-11-11 16:03:24 +0000
+++ plugins/UInput/plugin.cpp	2017-01-16 11:35:19 +0000
@@ -19,8 +19,14 @@
 
 #include <QtQml/qqml.h>
 
+
+QObject* uinputSingleton(QQmlEngine*, QJSEngine*)
+{
+    return new UInput;
+}
+
 void UInputPlugin::registerTypes(const char *uri)
 {
     Q_ASSERT(uri == QLatin1String("UInput"));
-    qmlRegisterType<UInput>(uri, 0, 1, "UInput");
+    qmlRegisterSingletonType<UInput>(uri, 0, 1, "UInput", uinputSingleton);
 }

=== modified file 'qml/CMakeLists.txt'
--- qml/CMakeLists.txt	2016-10-04 16:21:38 +0000
+++ qml/CMakeLists.txt	2017-01-16 11:35:19 +0000
@@ -1,4 +1,4 @@
-file(GLOB QML_JS_FILES *.qml *.js)
+file(GLOB QML_JS_FILES *.qml *.js qmldir)
 
 install(FILES ${QML_JS_FILES}
     DESTINATION ${SHELL_APP_DIR}

=== modified file 'qml/Components/PanelState/PanelState.qml'
--- qml/Components/PanelState/PanelState.qml	2016-09-29 09:15:04 +0000
+++ qml/Components/PanelState/PanelState.qml	2017-01-16 11:35:19 +0000
@@ -14,7 +14,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-pragma Singleton
 import QtQuick 2.4
 
 QtObject {

=== modified file 'qml/Components/PanelState/qmldir'
--- qml/Components/PanelState/qmldir	2014-11-24 11:21:38 +0000
+++ qml/Components/PanelState/qmldir	2017-01-16 11:35:19 +0000
@@ -1,1 +1,1 @@
-singleton PanelState 1.0 PanelState.qml
+PanelState 1.0 PanelState.qml

=== modified file 'qml/Components/VirtualTouchPad.qml'
--- qml/Components/VirtualTouchPad.qml	2016-12-05 11:17:15 +0000
+++ qml/Components/VirtualTouchPad.qml	2017-01-16 11:35:19 +0000
@@ -24,16 +24,14 @@
 
 Item {
     id: root
-    property var uinput: UInput {
-        Component.onCompleted: createMouse();
-        Component.onDestruction: removeMouse();
-    }
 
     Component.onCompleted: {
+        UInput.createMouse();
         if (!settings.touchpadTutorialHasRun) {
             root.runTutorial()
         }
     }
+    Component.onDestruction: UInput.removeMouse()
 
     function runTutorial() {
         // If the tutorial animation is started too early, e.g. in Component.onCompleted,
@@ -85,7 +83,7 @@
             if (((point1.pressed && !point2.pressed) || (!point1.pressed && point2.pressed))
                     && clickTimer.running) {
                 clickTimer.stop();
-                uinput.pressMouse(UInput.ButtonLeft)
+                UInput.pressMouse(UInput.ButtonLeft)
                 isDoubleClick = true;
             }
             isClick = true;
@@ -104,7 +102,7 @@
 
         onReleased: {
             if (isDoubleClick || isDrag) {
-                uinput.releaseMouse(UInput.ButtonLeft)
+                UInput.releaseMouse(UInput.ButtonLeft)
                 isDoubleClick = false;
             }
             if (isClick) {
@@ -120,8 +118,8 @@
             interval: 200
             property int button: UInput.ButtonLeft
             onTriggered: {
-                uinput.pressMouse(button);
-                uinput.releaseMouse(button);
+                UInput.pressMouse(button);
+                UInput.releaseMouse(button);
             }
             function scheduleClick(button) {
                 clickTimer.button = button;
@@ -138,7 +136,7 @@
                 isDrag = true;
             }
 
-            uinput.moveMouse(tp.x - tp.previousX, tp.y - tp.previousY);
+            UInput.moveMouse(tp.x - tp.previousX, tp.y - tp.previousY);
         }
 
         function scroll(touchPoints) {
@@ -166,7 +164,7 @@
             dh /= 2;
             dv /= 2;
 
-            uinput.scrollMouse(dh, dv);
+            UInput.scrollMouse(dh, dv);
         }
 
         touchPoints: [
@@ -189,8 +187,8 @@
             objectName: "leftButton"
             Layout.fillWidth: true
             Layout.fillHeight: true
-            onPressed: uinput.pressMouse(UInput.ButtonLeft);
-            onReleased: uinput.releaseMouse(UInput.ButtonLeft);
+            onPressed: UInput.pressMouse(UInput.ButtonLeft);
+            onReleased: UInput.releaseMouse(UInput.ButtonLeft);
             property bool highlight: false
             UbuntuShape {
                 anchors.fill: parent
@@ -204,8 +202,8 @@
             objectName: "rightButton"
             Layout.fillWidth: true
             Layout.fillHeight: true
-            onPressed: uinput.pressMouse(UInput.ButtonRight);
-            onReleased: uinput.releaseMouse(UInput.ButtonRight);
+            onPressed: UInput.pressMouse(UInput.ButtonRight);
+            onReleased: UInput.releaseMouse(UInput.ButtonRight);
             property bool highlight: false
             UbuntuShape {
                 anchors.fill: parent
@@ -239,14 +237,10 @@
         }
     }
 
-    Screens {
-        id: screens
-    }
-
     InputMethod {
         id: inputMethod
         // Don't resize when there is only one screen to avoid resize clashing with the InputMethod in the Shell.
-        enabled: screens.count > 1 && settings.oskEnabled && !tutorial.running
+        enabled: Screens.count > 1 && settings.oskEnabled && !tutorial.running
         objectName: "inputMethod"
         anchors.fill: parent
     }

=== modified file 'qml/DisabledScreenNotice.qml'
--- qml/DisabledScreenNotice.qml	2016-08-01 17:43:18 +0000
+++ qml/DisabledScreenNotice.qml	2017-01-16 11:35:19 +0000
@@ -28,8 +28,9 @@
     property var screen: Screen
     property var orientationLock: OrientationLock
 
+    property alias deviceConfiguration: _deviceConfiguration
     DeviceConfiguration {
-        id: deviceConfiguration
+        id: _deviceConfiguration
         name: applicationArguments.deviceName
     }
 

=== modified file 'qml/Greeter/Greeter.qml'
--- qml/Greeter/Greeter.qml	2016-11-29 00:13:45 +0000
+++ qml/Greeter/Greeter.qml	2017-01-16 11:35:19 +0000
@@ -25,6 +25,7 @@
 import Unity.Session 0.1
 
 import "." 0.1
+import ".." 0.1
 import "../Components"
 
 Showable {
@@ -234,7 +235,7 @@
             if (forcedUnlock && shown) {
                 hideView();
                 if (hideNow) {
-                    root.hideNow(); // skip hide animation
+                    ShellNotifier.greeter.hide(true); // skip hide animation
                 }
             }
         }
@@ -397,7 +398,7 @@
             onEmergencyCall: root.emergencyCall()
             onRequiredChanged: {
                 if (!loader.item.required) {
-                    root.hide();
+                    ShellNotifier.greeter.hide(false);
                 }
             }
         }
@@ -530,11 +531,28 @@
     }
 
     Connections {
+        target: ShellNotifier.greeter
+        onHide: {
+            if (now) {
+                root.hideNow(); // skip hide animation
+            } else {
+                root.hide();
+            }
+        }
+    }
+
+    Binding {
+        target: ShellNotifier.greeter
+        property: "shown"
+        value: root.shown
+    }
+
+    Connections {
         target: DBusUnitySessionService
         onLockRequested: root.forceShow()
         onUnlocked: {
             root.forcedUnlock = true;
-            root.hideNow();
+            ShellNotifier.greeter.hide(true);
         }
     }
 

=== added file 'qml/Greeter/SecondaryGreeter.qml'
--- qml/Greeter/SecondaryGreeter.qml	1970-01-01 00:00:00 +0000
+++ qml/Greeter/SecondaryGreeter.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C)  2016 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 "../Components"
+import ".." 0.1
+
+Showable {
+    id: root
+
+    readonly property bool active: required || hasLockedApp
+
+    readonly property bool hasLockedApp: lockedApp !== ""
+    readonly property bool locked: false
+    readonly property bool waiting: false
+    readonly property bool fullyShown: shown
+
+    property string lockedApp: ""
+
+    function forceShow() { show(); }
+    property var notifyAppFocusRequested: (function(appId) { return; })
+    property var notifyUserRequestedApp: (function(appId) { return; })
+    property var notifyShowingDashFromDrag: (function(appId) { return false; })
+
+    showAnimation: StandardAnimation { property: "opacity"; to: 1 }
+    hideAnimation: StandardAnimation { property: "opacity"; to: 0 }
+
+    shown: ShellNotifier.greeter.shown
+    Component.onCompleted: opacity = shown ? 1 : 0
+    visible: opacity != 0
+
+    Rectangle {
+        anchors.fill: parent
+        color: UbuntuColors.purple
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.AllButtons
+        onWheel: wheel.accepted = true
+    }
+
+    Connections {
+        target: ShellNotifier.greeter
+        onHide: {
+            if (now) {
+                root.hideNow(); // skip hide animation
+            } else {
+                root.hide();
+            }
+        }
+        onShownChanged: {
+            if (ShellNotifier.greeter.shown) {
+                root.show();
+            } else {
+                root.hide();
+            }
+        }
+    }
+}

=== modified file 'qml/OrientedShell.qml'
--- qml/OrientedShell.qml	2016-12-13 09:56:20 +0000
+++ qml/OrientedShell.qml	2017-01-16 11:35:19 +0000
@@ -32,15 +32,17 @@
     implicitWidth: units.gu(40)
     implicitHeight: units.gu(71)
 
+    property alias deviceConfiguration: _deviceConfiguration
+    property alias orientations: d.orientations
+    property alias surfaceManager: shell.surfaceManager
+
     onWidthChanged: calculateUsageMode();
 
     DeviceConfiguration {
-        id: deviceConfiguration
+        id: _deviceConfiguration
         name: applicationArguments.deviceName
     }
 
-    property alias orientations: d.orientations
-
     Item {
         id: d
 
@@ -157,10 +159,6 @@
         return false;
     }
 
-    Screens {
-        id: screens
-    }
-
     property int orientation
     onPhysicalOrientationChanged: {
         if (!orientationLocked) {
@@ -258,7 +256,7 @@
 
     Shell {
         id: shell
-        objectName: "shell"
+        objectName: "shell-"+screenWindow.objectName
         width: root.width
         height: root.height
         orientation: root.angleToOrientation(orientationAngle)
@@ -271,7 +269,7 @@
         //       have multiple keyboards around. For now we only enable one keyboard at a time
         //       thus hiding it here if there is a physical one around or if we have a second
         //       screen (the virtual touchpad & osk on the phone) attached.
-        oskEnabled: (keyboardsModel.count === 0 && screens.count === 1) ||
+        oskEnabled: (keyboardsModel.count === 0 && Screens.count === 1) ||
                     forceOSKEnabled
 
         usageScenario: {

=== modified file 'qml/Panel/Panel.qml'
--- qml/Panel/Panel.qml	2017-01-09 14:10:17 +0000
+++ qml/Panel/Panel.qml	2017-01-16 11:35:19 +0000
@@ -45,10 +45,16 @@
     property alias applicationMenus: __applicationMenus
     property alias indicators: __indicators
     property bool fullscreenMode: false
+<<<<<<< TREE
     property real panelAreaShowProgress: 1.0
     property bool greeterShown: false
 
     property string mode: "staged"
+=======
+    property real indicatorAreaShowProgress: 1.0
+    property bool locked: false
+    property PanelState panelState
+>>>>>>> MERGE-SOURCE
 
     MouseArea {
         id: backMouseEater
@@ -65,7 +71,7 @@
     }
 
     Binding {
-        target: PanelState
+        target: panelState
         property: "panelHeight"
         value: minimizedPanelHeight
     }
@@ -139,7 +145,11 @@
                 fill: panelAreaBackground
                 bottomMargin: -units.gu(1)
             }
+<<<<<<< TREE
             visible: PanelState.dropShadow
+=======
+            visible: panelState.dropShadow && !callHint.visible
+>>>>>>> MERGE-SOURCE
             source: "graphics/rectangular_dropshadow.sci"
         }
 
@@ -178,6 +188,7 @@
                 }
             }
 
+<<<<<<< TREE
             Row {
                 anchors.fill: parent
                 spacing: units.gu(2)
@@ -307,6 +318,31 @@
         }
 
         PanelMenu {
+=======
+            // WindowControlButtons inside the mouse area, otherwise QML doesn't grok nested hover events :/
+            // cf. https://bugreports.qt.io/browse/QTBUG-32909
+            WindowControlButtons {
+                id: windowControlButtons
+                objectName: "panelWindowControlButtons"
+                anchors {
+                    left: parent.left
+                    top: parent.top
+                }
+                height: indicators.minimizedPanelHeight
+
+                visible: ((panelState.buttonsVisible && parent.containsMouse) || panelState.buttonsAlwaysVisible)
+                         && !root.locked && !callHint.visible
+                active: panelState.buttonsVisible || panelState.buttonsAlwaysVisible
+                windowIsMaximized: true
+                onCloseClicked: panelState.closeClicked()
+                onMinimizeClicked: panelState.minimizeClicked()
+                onMaximizeClicked: panelState.restoreClicked()
+                closeButtonShown: panelState.closeButtonShown
+            }
+        }
+
+        IndicatorsMenu {
+>>>>>>> MERGE-SOURCE
             id: __indicators
             objectName: "indicators"
 
@@ -329,6 +365,7 @@
                     callHint.showLiveCall();
                 }
             }
+<<<<<<< TREE
 
             rowItemDelegate: IndicatorItem {
                 id: indicatorItem
@@ -401,6 +438,52 @@
 
     IndicatorsLight {
         id: indicatorLights
+=======
+        }
+
+        Label {
+            id: titleLabel
+            objectName: "windowDecorationTitle"
+            anchors {
+                left: parent.left
+                right: __indicators.left
+                top: parent.top
+                leftMargin: units.gu(1)
+                rightMargin: units.gu(1)
+                topMargin: units.gu(0.5)
+                bottomMargin: units.gu(0.5)
+            }
+            color: "white"
+            height: indicators.minimizedPanelHeight - anchors.topMargin - anchors.bottomMargin
+            opacity: !windowControlButtons.visible && !root.locked && !callHint.visible ? 1 : 0
+            visible: opacity != 0
+            verticalAlignment: Text.AlignVCenter
+            fontSize: "medium"
+            font.weight: panelState.buttonsVisible ? Font.Light : Font.Medium
+            text: panelState.title
+            elide: Text.ElideRight
+            maximumLineCount: 1
+            Behavior on opacity { UbuntuNumberAnimation {} }
+        }
+
+        // TODO here would the Locally integrated menus come
+
+        ActiveCallHint {
+            id: __callHint
+            anchors {
+                top: parent.top
+                left: parent.left
+            }
+            height: indicators.minimizedPanelHeight
+            visible: active && indicators.state == "initial"
+        }
+    }
+
+    QtObject {
+        id: d
+        objectName: "panelPriv"
+        readonly property real indicatorHeight: indicators.minimizedPanelHeight
+>>>>>>> MERGE-SOURCE
     }
 
     states: [

=== modified file 'qml/Shell.qml'
--- qml/Shell.qml	2017-01-03 12:04:08 +0000
+++ qml/Shell.qml	2017-01-16 11:35:19 +0000
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (C) 2013-2016 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -38,6 +38,7 @@
 import "Stage"
 import "Tutorial"
 import "Wizard"
+import "Components/PanelState"
 import Unity.Notifications 1.0 as NotificationBackend
 import Unity.Session 0.1
 import Unity.DashCommunicator 0.1
@@ -52,6 +53,7 @@
     theme.name: "Ubuntu.Components.Themes.SuruDark"
 
     // to be set from outside
+    property alias surfaceManager: topLevelSurfaceList.surfaceManager
     property int orientationAngle: 0
     property int orientation
     property Orientations orientations
@@ -249,7 +251,6 @@
             var mappedCoords = mapFromItem(null, pos.x, pos.y);
             cursor.x = mappedCoords.x;
             cursor.y = mappedCoords.y;
-            cursor.mouseNeverMoved = false;
         }
     }
 
@@ -258,21 +259,21 @@
         schema.id: "com.canonical.Unity8"
     }
 
+    PanelState {
+        id: panelState
+        objectName: "panelState"
+    }
+
     Item {
         id: stages
         objectName: "stages"
         width: parent.width
         height: parent.height
 
-        SurfaceManager {
-            id: surfaceMan
-            objectName: "surfaceManager"
-        }
         TopLevelWindowModel {
             id: topLevelSurfaceList
             objectName: "topLevelSurfaceList"
             applicationManager: ApplicationManager // it's a singleton
-            surfaceManager: surfaceMan
         }
 
         Stage {
@@ -313,11 +314,15 @@
             altTabPressed: physicalKeysMapper.altTabPressed
             oskEnabled: shell.oskEnabled
             spreadEnabled: tutorial.spreadEnabled && (!greeter || (!greeter.hasLockedApp && !greeter.shown))
+<<<<<<< TREE
 
             onSpreadShownChanged: {
                 panel.indicators.hide();
                 panel.applicationMenus.hide();
             }
+=======
+            panelState: panelState
+>>>>>>> MERGE-SOURCE
         }
     }
 
@@ -338,8 +343,13 @@
         objectName: "greeterLoader"
         anchors.fill: parent
         anchors.topMargin: panel.panelHeight
-        sourceComponent: shell.mode != "shell" ? integratedGreeter :
-            Qt.createComponent(Qt.resolvedUrl("Greeter/ShimGreeter.qml"));
+        sourceComponent: {
+            if (shell.mode != "shell") {
+                if (screenWindow.primary) return integratedGreeter;
+                return secondaryGreeter;
+            }
+            return Qt.createComponent(Qt.resolvedUrl("Greeter/ShimGreeter.qml"));
+        }
         onLoaded: {
             item.objectName = "greeter"
         }
@@ -379,6 +389,13 @@
         }
     }
 
+    Component {
+        id: secondaryGreeter
+        SecondaryGreeter {
+            hides: [launcher, panel.indicators]
+        }
+    }
+
     Timer {
         // See powerConnection for why this is useful
         id: showGreeterDelayed
@@ -488,7 +505,12 @@
                 : false
             fullscreenMode: (focusedSurfaceIsFullscreen && !LightDMService.greeter.active && launcher.progress == 0)
                             || greeter.hasLockedApp
+<<<<<<< TREE
             greeterShown: greeter && greeter.shown
+=======
+            locked: greeter && greeter.active
+            panelState: panelState
+>>>>>>> MERGE-SOURCE
         }
 
         Launcher {
@@ -699,23 +721,13 @@
 
     Cursor {
         id: cursor
-        objectName: "cursor"
         visible: shell.hasMouse
         z: itemGrabber.z + 1
+        opacity: 0
         topBoundaryOffset: panel.panelHeight
 
         confiningItem: stage.itemConfiningMouseCursor
 
-        property bool mouseNeverMoved: true
-        Binding {
-            target: cursor; property: "x"; value: shell.width / 2
-            when: cursor.mouseNeverMoved && cursor.visible
-        }
-        Binding {
-            target: cursor; property: "y"; value: shell.height / 2
-            when: cursor.mouseNeverMoved && cursor.visible
-        }
-
         height: units.gu(3)
 
         readonly property var previewRectangle: stage.previewRectangle.target &&
@@ -770,7 +782,6 @@
         }
 
         onMouseMoved: {
-            mouseNeverMoved = false;
             cursor.opacity = 1;
         }
 

=== added file 'qml/ShellApplication.qml'
--- qml/ShellApplication.qml	1970-01-01 00:00:00 +0000
+++ qml/ShellApplication.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,51 @@
+/*
+* Copyright (C) 2016 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.Window 2.2
+import Unity.Screens 0.1
+import Unity.Application 0.1
+
+Instantiator {
+    id: root
+    model: Screens
+
+    property QtObject surfaceMan: SurfaceManager {}
+
+    ShellScreen {
+        id: screen
+        objectName: "screen"+index
+        screen: model.screen
+        visibility:  applicationArguments.hasFullscreen ? Window.FullScreen : Window.Windowed
+        flags: applicationArguments.hasFrameless ? Qt.FramelessWindowHint : 0
+        surfaceManager: surfaceMan
+
+        Binding {
+            when: applicationArguments.hasGeometry
+            target: screen
+            property: "width"
+            value: applicationArguments.windowGeometry.width
+        }
+        Binding {
+            when: applicationArguments.hasGeometry
+            target: screen
+            property: "height"
+            value: applicationArguments.windowGeometry.height
+        }
+
+        primary: index == 0
+    }
+}

=== added file 'qml/ShellNotifier.qml'
--- qml/ShellNotifier.qml	1970-01-01 00:00:00 +0000
+++ qml/ShellNotifier.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 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/>.
+ */
+
+/*
+    Shared signals & properties on multi-window desktop
+ */
+
+pragma Singleton
+import QtQuick 2.4
+
+QtObject {
+    property var greeter: QtObject {
+        signal hide(bool now)
+
+        property bool shown: true
+    }
+}

=== added file 'qml/ShellScreen.qml'
--- qml/ShellScreen.qml	1970-01-01 00:00:00 +0000
+++ qml/ShellScreen.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,65 @@
+/*
+* Copyright (C) 2016 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.Screens 0.1
+import Cursor 1.1
+import "Components"
+
+ScreenWindow {
+    id: screenWindow
+
+    color: "black"
+    title: "Unity8 Shell"
+    property bool primary: false
+    property QtObject surfaceManager: null
+
+    DeviceConfiguration {
+        id: deviceConfiguration
+        name: applicationArguments.deviceName
+    }
+
+    Loader {
+        width: screenWindow.width
+        height: screenWindow.height
+
+        sourceComponent: {
+            if (Screens.count > 1 && primary && deviceConfiguration.category !== "desktop") {
+                return disabledScreenComponent;
+            }
+            return shellComponent;
+        }
+    }
+
+    Component {
+        id: shellComponent
+        OrientedShell {
+            implicitWidth: screenWindow.width
+            implicitHeight: screenWindow.height
+            surfaceManager: screenWindow.surfaceManager
+
+            deviceConfiguration {
+                name: Screens.count > 1 ? "desktop" : applicationArguments.deviceName
+            }
+        }
+    }
+
+    Component {
+        id: disabledScreenComponent
+        DisabledScreenNotice {}
+    }
+}

=== modified file 'qml/Stage/DecoratedWindow.qml'
--- qml/Stage/DecoratedWindow.qml	2016-12-12 11:16:47 +0000
+++ qml/Stage/DecoratedWindow.qml	2017-01-16 11:35:19 +0000
@@ -18,9 +18,13 @@
 import Ubuntu.Components 1.3
 import Unity.Application 0.1
 import "Spread/MathUtils.js" as MathUtils
+<<<<<<< TREE
 import Unity.ApplicationMenu 0.1
 import Unity.Indicators 0.1 as Indicators
 import "../Components/PanelState"
+=======
+import "../Components/PanelState"
+>>>>>>> MERGE-SOURCE
 
 FocusScope {
     id: root
@@ -73,6 +77,8 @@
 
     readonly property Item clientAreaItem: applicationWindow
 
+    property PanelState panelState
+
     signal closeClicked()
     signal maximizeClicked()
     signal maximizeHorizontallyClicked()
@@ -150,6 +156,44 @@
         opacity: root.shadowOpacity
     }
 
+<<<<<<< TREE
+=======
+    WindowDecoration {
+        id: decoration
+        closeButtonVisible: root.application.appId !== "unity8-dash"
+        objectName: "appWindowDecoration"
+        anchors { left: parent.left; top: parent.top; right: parent.right }
+        height: units.gu(3)
+        width: root.width
+        title: applicationWindow.title
+        opacity: root.hasDecoration ? Math.min(1, root.showDecoration) : 0
+
+        Behavior on opacity { UbuntuNumberAnimation { } }
+
+        onCloseClicked: root.closeClicked();
+        onMaximizeClicked: { root.decorationPressed(); root.maximizeClicked(); }
+        onMaximizeHorizontallyClicked: { root.decorationPressed(); root.maximizeHorizontallyClicked(); }
+        onMaximizeVerticallyClicked: { root.decorationPressed(); root.maximizeVerticallyClicked(); }
+        onMinimizeClicked: root.minimizeClicked();
+        onPressed: root.decorationPressed();
+
+        onPressedChanged: moveHandler.handlePressedChanged(pressed, pressedButtons, mouseX, mouseY)
+        onPositionChanged: moveHandler.handlePositionChanged(mouse)
+        onReleased: {
+            root.decorationReleased();
+            moveHandler.handleReleased();
+        }
+    }
+
+    MoveHandler {
+        id: moveHandler
+        objectName: "moveHandler"
+        target: root.parent
+        buttonsWidth: decoration.buttonsWidth
+        panelState: root.panelState
+    }
+
+>>>>>>> MERGE-SOURCE
     ApplicationWindow {
         id: applicationWindow
         objectName: "appWindow"

=== modified file 'qml/Stage/FakeMaximizeDelegate.qml'
--- qml/Stage/FakeMaximizeDelegate.qml	2016-11-30 19:24:02 +0000
+++ qml/Stage/FakeMaximizeDelegate.qml	2017-01-16 11:35:19 +0000
@@ -35,6 +35,7 @@
     property int leftMargin
     property real appContainerWidth
     property real appContainerHeight
+    property PanelState panelState
 
     readonly property real hintThreshold: 0.1
 
@@ -178,7 +179,7 @@
     ParallelAnimation {
         id: fakeMaximizeAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: appContainerWidth - leftMargin }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight }
     }
@@ -186,39 +187,39 @@
     ParallelAnimation {
         id: fakeMaximizeLeftAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - panelState.panelHeight }
     }
 
     ParallelAnimation {
         id: fakeMaximizeRightAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight - panelState.panelHeight }
     }
 
     ParallelAnimation {
         id: fakeMaximizeTopLeftAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - PanelState.panelHeight)/2 }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - panelState.panelHeight)/2 }
     }
 
     ParallelAnimation {
         id: fakeMaximizeTopRightAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: PanelState.panelHeight }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: panelState.panelHeight }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - PanelState.panelHeight)/2 }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight - panelState.panelHeight)/2 }
     }
 
     ParallelAnimation {
         id: fakeMaximizeBottomLeftAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: leftMargin }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + PanelState.panelHeight)/2 }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + panelState.panelHeight)/2 }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }
     }
@@ -226,7 +227,7 @@
     ParallelAnimation {
         id: fakeMaximizeBottomRightAnimation
         UbuntuNumberAnimation { target: fakeRectangle; properties: "x"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth + leftMargin)/2 }
-        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + PanelState.panelHeight)/2 }
+        UbuntuNumberAnimation { target: fakeRectangle; properties: "y"; duration: UbuntuAnimation.BriskDuration; to: (appContainerHeight + panelState.panelHeight)/2 }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "width"; duration: UbuntuAnimation.BriskDuration; to: (appContainerWidth - leftMargin)/2 }
         UbuntuNumberAnimation { target: fakeRectangle; properties: "height"; duration: UbuntuAnimation.BriskDuration; to: appContainerHeight/2 }
     }

=== modified file 'qml/Stage/MoveHandler.qml'
--- qml/Stage/MoveHandler.qml	2016-12-12 16:45:09 +0000
+++ qml/Stage/MoveHandler.qml	2017-01-16 11:35:19 +0000
@@ -28,6 +28,7 @@
     property int stageWidth
     property int stageHeight
     property real buttonsWidth: 0
+    property PanelState panelState
 
     readonly property bool dragging: priv.dragging
 
@@ -122,18 +123,18 @@
             // position. Mouse movement could have subpixel precision, yielding a fractional
             // mouse position.
             target.windowedX = Math.round(pos.x - priv.distanceX);
-            target.windowedY = Math.round(Math.max(pos.y - priv.distanceY, PanelState.panelHeight));
+            target.windowedY = Math.round(Math.max(pos.y - priv.distanceY, panelState.panelHeight));
 
             if (sensingPoints) { // edge/corner detection when dragging via the touch overlay
-                if (sensingPoints.topLeft.x < priv.triggerArea && sensingPoints.topLeft.y < PanelState.panelHeight + priv.triggerArea
+                if (sensingPoints.topLeft.x < priv.triggerArea && sensingPoints.topLeft.y < panelState.panelHeight + priv.triggerArea
                         && target.canBeCornerMaximized) { // top left
-                    priv.progress = priv.progressInCorner(0, PanelState.panelHeight, sensingPoints.topLeft.x, sensingPoints.topLeft.y);
+                    priv.progress = priv.progressInCorner(0, panelState.panelHeight, sensingPoints.topLeft.x, sensingPoints.topLeft.y);
                     priv.resetEdges();
                     priv.nearTopLeftCorner = true;
                     root.fakeMaximizeTopLeftAnimationRequested(priv.progress);
-                } else if (sensingPoints.topRight.x > stageWidth - priv.triggerArea && sensingPoints.topRight.y < PanelState.panelHeight + priv.triggerArea
+                } else if (sensingPoints.topRight.x > stageWidth - priv.triggerArea && sensingPoints.topRight.y < panelState.panelHeight + priv.triggerArea
                            && target.canBeCornerMaximized) { // top right
-                    priv.progress = priv.progressInCorner(stageWidth, PanelState.panelHeight, sensingPoints.topRight.x, sensingPoints.topRight.y);
+                    priv.progress = priv.progressInCorner(stageWidth, panelState.panelHeight, sensingPoints.topRight.x, sensingPoints.topRight.y);
                     priv.resetEdges();
                     priv.nearTopRightCorner = true;
                     root.fakeMaximizeTopRightAnimationRequested(priv.progress);
@@ -159,8 +160,8 @@
                     priv.resetEdges();
                     priv.nearRightEdge = true;
                     root.fakeMaximizeRightAnimationRequested(priv.progress);
-                } else if (sensingPoints.top.y < PanelState.panelHeight + priv.triggerArea && target.canBeMaximized) { // top
-                    priv.progress = MathUtils.clampAndProject(sensingPoints.top.y, PanelState.panelHeight + priv.triggerArea, 0, 0, 1);
+                } else if (sensingPoints.top.y < panelState.panelHeight + priv.triggerArea && target.canBeMaximized) { // top
+                    priv.progress = MathUtils.clampAndProject(sensingPoints.top.y, panelState.panelHeight + priv.triggerArea, 0, 0, 1);
                     priv.resetEdges();
                     priv.nearTopEdge = true;
                     root.fakeMaximizeAnimationRequested(priv.progress);

=== added file 'qml/Stage/Spread/ScreensAndWorkspaces.qml'
--- qml/Stage/Spread/ScreensAndWorkspaces.qml	1970-01-01 00:00:00 +0000
+++ qml/Stage/Spread/ScreensAndWorkspaces.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,75 @@
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+import Unity.Screens 0.1
+import Unity.Application 0.1
+import ".."
+
+Item {
+    id: root
+
+
+    Rectangle { anchors.fill: parent; color: "blue"; opacity: .3 }
+
+    Row {
+        anchors.centerIn: parent
+        spacing: units.gu(1)
+
+        Repeater {
+            model: Screens
+
+            delegate: Rectangle {
+                id: previewSpace
+                height: root.height * .5
+                width: height * 1.4
+                color: "red"
+
+                property int screenWidth: model.geometry.width
+                property int screenHeight: model.geometry.height
+
+                Label {
+                    text: model.name + "," + model.geometry.width
+                }
+
+                Rectangle {
+                    anchors.fill: parent
+                    anchors.topMargin: units.gu(4)
+
+                    Repeater {
+                        id: topLevelSurfaceRepeater
+                        model: topLevelSurfaceList
+                        delegate: Rectangle {
+                            width: surfaceItem.width
+                            height: surfaceItem.height
+                            x: model.window.position.x * surfaceItem.previewScale
+                            y: model.window.position.y * surfaceItem.previewScale
+                            color: "blue"
+                            z: topLevelSurfaceRepeater.count - index
+
+
+                            MirSurfaceItem {
+                                id: surfaceItem
+
+                                property real previewScale: previewSpace.width / previewSpace.screenWidth
+
+                                width: implicitWidth * previewScale
+                                height: implicitHeight * previewScale
+//                                fillMode: MirSurfaceItem.Stretch
+                                surfaceWidth: -1
+                                surfaceHeight: -1
+                                onImplicitHeightChanged: print("item", surfaceItem, "height changed", implicitHeight)
+    //                            surfaceWidth: 100
+    //                            surfaceHeight: 100
+    //                            requestedHeight: 100// -1// !counterRotate ? root.requestedHeight - d.requestedDecorationHeight : root.requestedWidth
+    //                            requestedWidth: 100// -1// !counterRotate ? root.requestedWidth : root.requestedHeight - d.requestedDecorationHeight
+
+    //                            application: model.application
+                                surface: model.window.surface
+                            }
+                        }
+                    }
+                }
+
+            }
+        }
+    }
+}

=== modified file 'qml/Stage/Spread/Spread.qml'
--- qml/Stage/Spread/Spread.qml	2016-11-07 12:37:56 +0000
+++ qml/Stage/Spread/Spread.qml	2017-01-16 11:35:19 +0000
@@ -28,10 +28,10 @@
     property var spreadFlickable
 
     // some config options
-    property real contentMargin: 0.16 * root.height
-    property real contentTopMargin: contentMargin
-    property real contentBottomMargin: 0.35 * contentMargin
-    property real windowTitleTopMargin: 3/4 * (contentTopMargin - windowTitle.height)
+    property real contentMargin: 0.1 * root.height
+    property real contentTopMargin: contentMargin + root.y + windowTitle.height
+    property real contentBottomMargin: contentMargin
+    property real windowTitleTopMargin: contentMargin - windowTitle.height
     property int stackItemCount: 3
     property real leftRotationAngle: 22
     property real rightRotationAngle: 32
@@ -51,7 +51,7 @@
 
     readonly property real spreadWidth: rightStackXPos - leftStackXPos
     readonly property real spreadHeight: root.height
-    readonly property real spreadItemHeight: spreadHeight - contentTopMargin - contentBottomMargin
+    readonly property real spreadItemHeight: spreadHeight - contentMargin * 2
     readonly property real spreadItemWidth: stackHeight
 
     readonly property real dynamicLeftRotationAngle: leftRotationAngle * rotationAngleFactor

=== modified file 'qml/Stage/Stage.qml'
--- qml/Stage/Stage.qml	2017-01-03 12:04:08 +0000
+++ qml/Stage/Stage.qml	2017-01-16 11:35:19 +0000
@@ -46,6 +46,7 @@
     property int leftMargin: 0
     property bool oskEnabled: false
     property rect inputMethodRect
+    property PanelState panelState
 
     // Configuration
     property string mode: "staged"
@@ -348,20 +349,25 @@
     Component.onCompleted: priv.updateMainAndSideStageIndexes();
 
     Connections {
-        target: PanelState
+        target: panelState
         onCloseClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.close(); } }
         onMinimizeClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestMinimize(); } }
         onRestoreClicked: { if (priv.focusedAppDelegate) { priv.focusedAppDelegate.requestRestore(); } }
     }
 
     Binding {
+<<<<<<< TREE
         target: PanelState
         property: "decorationsVisible"
+=======
+        target: panelState
+        property: "buttonsVisible"
+>>>>>>> MERGE-SOURCE
         value: priv.focusedAppDelegate !== null && priv.focusedAppDelegate.maximized // FIXME for Locally integrated menus
     }
 
     Binding {
-        target: PanelState
+        target: panelState
         property: "title"
         value: {
             if (priv.focusedAppDelegate !== null) {
@@ -376,6 +382,7 @@
     }
 
     Binding {
+<<<<<<< TREE
         target: PanelState
         property: "focusedPersistentSurfaceId"
         value: {
@@ -391,20 +398,29 @@
 
     Binding {
         target: PanelState
+=======
+        target: panelState
+>>>>>>> MERGE-SOURCE
         property: "dropShadow"
         value: priv.focusedAppDelegate && !priv.focusedAppDelegate.maximized && priv.foregroundMaximizedAppDelegate !== null && mode == "windowed"
     }
 
     Binding {
-        target: PanelState
+        target: panelState
         property: "closeButtonShown"
         value: priv.focusedAppDelegate && priv.focusedAppDelegate.maximized && !priv.focusedAppDelegate.isDash
     }
 
     Component.onDestruction: {
+<<<<<<< TREE
         PanelState.title = "";
         PanelState.decorationsVisible = false;
         PanelState.dropShadow = false;
+=======
+        panelState.title = "";
+        panelState.buttonsVisible = false;
+        panelState.dropShadow = false;
+>>>>>>> MERGE-SOURCE
     }
 
     Instantiator {
@@ -482,7 +498,7 @@
         },
         State {
             name: "staged"; when: root.mode === "staged"
-            PropertyChanges { target: wallpaper; visible: false }
+            PropertyChanges { target: wallpaper; visible: priv.focusedAppDelegate && priv.focusedAppDelegate.x === 0 }
         },
         State {
             name: "stagedWithSideStage"; when: root.mode === "stagedWithSideStage"
@@ -559,10 +575,16 @@
             visible: false
         }
 
+        ScreensAndWorkspaces {
+            id: screensAndWorkspaces
+            anchors { left: parent.left; top: parent.top; right: parent.right }
+            height: parent.height / 3
+        }
+
         Spread {
             id: spreadItem
             objectName: "spreadItem"
-            anchors.fill: appContainer
+            anchors { left: parent.left; bottom: parent.bottom; right: parent.right; top: screensAndWorkspaces.bottom }
             leftMargin: root.leftMargin
             model: root.topLevelSurfaceList
             spreadFlickable: floatingFlickable
@@ -753,7 +775,7 @@
                     target: appDelegate
                     property: "y"
                     value: appDelegate.requestedY -
-                           Math.min(appDelegate.requestedY - PanelState.panelHeight,
+                           Math.min(appDelegate.requestedY - panelState.panelHeight,
                                     Math.max(0, priv.virtualKeyboardHeight - (appContainer.height - (appDelegate.requestedY + appDelegate.height))))
                     when: root.oskEnabled && appDelegate.focus && (appDelegate.state == "normal" || appDelegate.state == "restored")
                           && root.inputMethodRect.height > 0
@@ -890,7 +912,7 @@
                     screenWidth: appContainer.width
                     screenHeight: appContainer.height
                     leftMargin: root.leftMargin
-                    minimumY: PanelState.panelHeight
+                    minimumY: panelState.panelHeight
                 }
 
                 Connections {
@@ -1130,7 +1152,7 @@
                     progress: 0
                     targetHeight: spreadItem.stackHeight
                     targetX: spreadMaths.targetX
-                    startY: appDelegate.fullscreen ? 0 : PanelState.panelHeight
+                    startY: appDelegate.fullscreen ? 0 : panelState.panelHeight
                     targetY: spreadMaths.targetY
                     targetAngle: spreadMaths.targetAngle
                     targetScale: spreadMaths.targetScale
@@ -1249,9 +1271,9 @@
                         PropertyChanges {
                             target: appDelegate
                             x: stageMaths.itemX
-                            y: appDelegate.fullscreen ? 0 : PanelState.panelHeight
+                            y: appDelegate.fullscreen ? 0 : panelState.panelHeight
                             requestedWidth: appContainer.width
-                            requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight
+                            requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight
                             visuallyMaximized: true
                             visible: appDelegate.x < root.width
                         }
@@ -1277,10 +1299,10 @@
                         PropertyChanges {
                             target: appDelegate
                             x: stageMaths.itemX
-                            y: appDelegate.fullscreen ? 0 : PanelState.panelHeight
+                            y: appDelegate.fullscreen ? 0 : panelState.panelHeight
                             z: stageMaths.itemZ
                             requestedWidth: stageMaths.itemWidth
-                            requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - PanelState.panelHeight
+                            requestedHeight: appDelegate.fullscreen ? appContainer.height : appContainer.height - panelState.panelHeight
                             visuallyMaximized: true
                             visible: appDelegate.x < root.width
                         }
@@ -1345,9 +1367,9 @@
                         PropertyChanges {
                             target: appDelegate
                             windowedX: root.leftMargin
-                            windowedY: PanelState.panelHeight
+                            windowedY: panelState.panelHeight
                             windowedWidth: (appContainer.width - root.leftMargin)/2
-                            windowedHeight: appContainer.height - PanelState.panelHeight
+                            windowedHeight: appContainer.height - panelState.panelHeight
                         }
                     },
                     State {
@@ -1364,9 +1386,9 @@
                         PropertyChanges {
                             target: appDelegate
                             windowedX: root.leftMargin
-                            windowedY: PanelState.panelHeight
+                            windowedY: panelState.panelHeight
                             windowedWidth: (appContainer.width - root.leftMargin)/2
-                            windowedHeight: (appContainer.height - PanelState.panelHeight)/2
+                            windowedHeight: (appContainer.height - panelState.panelHeight)/2
                         }
                     },
                     State {
@@ -1383,7 +1405,7 @@
                         PropertyChanges {
                             target: appDelegate
                             windowedX: root.leftMargin
-                            windowedY: (appContainer.height + PanelState.panelHeight)/2
+                            windowedY: (appContainer.height + panelState.panelHeight)/2
                             windowedWidth: (appContainer.width - root.leftMargin)/2
                             windowedHeight: appContainer.height/2
                         }
@@ -1405,8 +1427,8 @@
                     State {
                         name: "maximizedVertically"; when: appDelegate.maximizedVertically && !appDelegate.minimized
                         extend: "normal"
-                        PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: PanelState.panelHeight;
-                            windowedWidth: windowedWidth; windowedHeight: appContainer.height - PanelState.panelHeight }
+                        PropertyChanges { target: appDelegate; windowedX: windowedX; windowedY: panelState.panelHeight;
+                            windowedWidth: windowedWidth; windowedHeight: appContainer.height - panelState.panelHeight }
                     },
                     State {
                         name: "minimized"; when: appDelegate.minimized
@@ -1505,8 +1527,13 @@
                 ]
 
                 Binding {
+<<<<<<< TREE
                     target: PanelState
                     property: "decorationsAlwaysVisible"
+=======
+                    target: panelState
+                    property: "buttonsAlwaysVisible"
+>>>>>>> MERGE-SOURCE
                     value: appDelegate && appDelegate.maximized && touchControls.overlayShown
                 }
 
@@ -1520,7 +1547,7 @@
                     anchors.margins: touchControls.overlayShown ? borderThickness/2 : -borderThickness
 
                     target: appDelegate
-                    minimumY: PanelState.panelHeight // disallow resizing up past Panel
+                    minimumY: panelState.panelHeight // disallow resizing up past Panel
                     minWidth: units.gu(10)
                     minHeight: units.gu(10)
                     borderThickness: units.gu(2)
@@ -1550,6 +1577,7 @@
                     highlightSize: windowInfoItem.iconMargin / 2
                     stageWidth: appContainer.width
                     stageHeight: appContainer.height
+                    panelState: root.panelState
 
                     requestedWidth: appDelegate.requestedWidth
                     requestedHeight: appDelegate.requestedHeight
@@ -1609,6 +1637,7 @@
                     visible: enabled
                     stageWidth: appContainer.width
                     stageHeight: appContainer.height
+                    panelState: root.panelState
 
                     onFakeMaximizeAnimationRequested: if (!appDelegate.maximized) fakeRectangle.maximize(amount, true)
                     onFakeMaximizeLeftAnimationRequested: if (!appDelegate.maximizedLeft) fakeRectangle.maximizeLeft(amount, true)
@@ -1713,6 +1742,7 @@
         leftMargin: root.leftMargin
         appContainerWidth: appContainer.width
         appContainerHeight: appContainer.height
+        panelState: root.panelState
     }
 
     EdgeBarrier {

=== modified file 'qml/Stage/SurfaceContainer.qml'
--- qml/Stage/SurfaceContainer.qml	2016-09-22 13:35:35 +0000
+++ qml/Stage/SurfaceContainer.qml	2017-01-16 11:35:19 +0000
@@ -66,6 +66,8 @@
         fillMode: MirSurfaceItem.PadOrCrop
         consumesInput: true
 
+        onSurfaceChanged: print("surface changed", surface, implicitWidth, implicitHeight)
+
         surfaceWidth: root.requestedWidth
         surfaceHeight: root.requestedHeight
 

=== modified file 'qml/Stage/WindowControlsOverlay.qml'
--- qml/Stage/WindowControlsOverlay.qml	2016-12-27 22:09:12 +0000
+++ qml/Stage/WindowControlsOverlay.qml	2017-01-16 11:35:19 +0000
@@ -27,6 +27,7 @@
 
     // to be set from outside
     property Item target // appDelegate
+    property PanelState panelState
     property alias stageWidth: moveHandler.stageWidth
     property alias stageHeight: moveHandler.stageHeight
 
@@ -161,6 +162,7 @@
                 id: moveHandler
                 objectName: "moveHandler"
                 target: root.target
+                panelState: root.panelState
 
                 onFakeMaximizeAnimationRequested: root.fakeMaximizeAnimationRequested(amount)
                 onFakeMaximizeLeftAnimationRequested: root.fakeMaximizeLeftAnimationRequested(amount)

=== added file 'qml/qmldir'
--- qml/qmldir	1970-01-01 00:00:00 +0000
+++ qml/qmldir	2017-01-16 11:35:19 +0000
@@ -0,0 +1,1 @@
+singleton ShellNotifier 0.1 ShellNotifier.qml

=== modified file 'src/ApplicationArguments.cpp'
--- src/ApplicationArguments.cpp	2015-03-06 04:44:11 +0000
+++ src/ApplicationArguments.cpp	2017-01-16 11:35:19 +0000
@@ -16,7 +16,16 @@
 
 #include "ApplicationArguments.h"
 
-ApplicationArguments::ApplicationArguments(QObject *parent)
-    : QObject(parent)
-{
+ApplicationArguments::ApplicationArguments(QCoreApplication *app)
+    : QObject(app)
+    , UnityCommandLineParser(*app)
+{
+}
+
+void ApplicationArguments::setDeviceName(const QString &deviceName)
+{
+    if (deviceName != m_deviceName) {
+        m_deviceName = deviceName;
+        Q_EMIT deviceNameChanged(m_deviceName);
+    }
 }

=== modified file 'src/ApplicationArguments.h'
--- src/ApplicationArguments.h	2015-10-05 16:43:41 +0000
+++ src/ApplicationArguments.h	2017-01-16 11:35:19 +0000
@@ -23,31 +23,32 @@
 #include <QSize>
 #include <QString>
 
-class ApplicationArguments : public QObject
+#include "UnityCommandLineParser.h"
+
+class ApplicationArguments : public QObject,
+                             public UnityCommandLineParser
 {
     Q_OBJECT
     Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)
     Q_PROPERTY(QString mode READ mode CONSTANT)
+
+    Q_PROPERTY(bool hasGeometry READ hasGeometry CONSTANT)
+    Q_PROPERTY(QSize windowGeometry READ windowGeometry CONSTANT)
+    Q_PROPERTY(bool hasTestability READ hasTestability CONSTANT)
+    Q_PROPERTY(bool hasFrameless READ hasFrameless CONSTANT)
+#ifdef UNITY8_ENABLE_TOUCH_EMULATION
+    Q_PROPERTY(bool hasMouseToTouch READ hasMouseToTouch CONSTANT)
+#endif
+
 public:
-    ApplicationArguments(QObject *parent = nullptr);
-
-    void setDeviceName(const QString &deviceName) {
-        if (deviceName != m_deviceName) {
-            m_deviceName = deviceName;
-            Q_EMIT deviceNameChanged(m_deviceName);
-        }
-    }
-    QString deviceName() const { return m_deviceName; }
-
-    void setMode(const QString &mode) { m_mode = mode; }
-    QString mode() const { return m_mode; }
+    ApplicationArguments(QCoreApplication *app);
+
+    void setDeviceName(const QString &deviceName);
+
+    bool hasGeometry() const { return m_windowGeometry.isValid(); }
 
 Q_SIGNALS:
     void deviceNameChanged(const QString&);
-
-private:
-    QString m_deviceName;
-    QString m_mode;
 };
 
 #endif // APPLICATION_ARGUMENTS_H

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-12-14 16:49:09 +0000
+++ src/CMakeLists.txt	2017-01-16 11:35:19 +0000
@@ -27,9 +27,7 @@
     ApplicationArguments.cpp
     main.cpp
     CachingNetworkManagerFactory.cpp
-    SecondaryWindow.cpp
     ShellApplication.cpp
-    ShellView.cpp
     UnityCommandLineParser.cpp
     UnixSignalHandler.cpp
     DebuggingController.cpp

=== removed file 'src/SecondaryWindow.cpp'
--- src/SecondaryWindow.cpp	2016-05-09 12:25:29 +0000
+++ src/SecondaryWindow.cpp	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * 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/>.
- */
-
-#include "SecondaryWindow.h"
-
-// local
-#include <paths.h>
-
-#include <QQmlContext>
-
-SecondaryWindow::SecondaryWindow(QQmlEngine *engine)
-    : QQuickView(engine, nullptr)
-{
-    QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");
-    bool ok;
-    int pxpgu = pxpguEnv.toInt(&ok);
-    if (!ok) {
-        pxpgu = 8;
-    }
-    engine->rootContext()->setContextProperty(QStringLiteral("internalGu"), pxpgu);
-    setResizeMode(QQuickView::SizeRootObjectToView);
-    setColor("black");
-    setTitle(QStringLiteral("Unity8 Shell - Secondary Screen"));
-
-    QUrl source(::qmlDirectory() + "/DisabledScreenNotice.qml");
-    setSource(source);
-}

=== removed file 'src/SecondaryWindow.h'
--- src/SecondaryWindow.h	2015-10-02 21:50:07 +0000
+++ src/SecondaryWindow.h	1970-01-01 00:00:00 +0000
@@ -1,30 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef UNITY_SECONDARY_WINDOW_H
-#define UNITY_SECONDARY_WINDOW_H
-
-#include <QQuickView>
-
-class SecondaryWindow : public QQuickView
-{
-    Q_OBJECT
-
-public:
-    SecondaryWindow(QQmlEngine *engine);
-};
-
-#endif // UNITY_SECONDARY_WINDOW_H

=== modified file 'src/ShellApplication.cpp'
--- src/ShellApplication.cpp	2017-01-10 14:46:22 +0000
+++ src/ShellApplication.cpp	2017-01-16 11:35:19 +0000
@@ -20,6 +20,7 @@
 #include <QLibrary>
 #include <QProcess>
 #include <QScreen>
+#include <QQmlContext>
 
 #include <libintl.h>
 
@@ -34,30 +35,22 @@
 
 ShellApplication::ShellApplication(int & argc, char ** argv, bool isMirServer)
     : QGuiApplication(argc, argv)
+    , m_qmlArgs(this)
 {
     setApplicationName(QStringLiteral("unity8"));
     setOrganizationName(QStringLiteral("Canonical"));
 
-    connect(this, &QGuiApplication::screenAdded, this, &ShellApplication::onScreenAdded);
-
     setupQmlEngine(isMirServer);
 
-    UnityCommandLineParser parser(*this);
-
-    if (!parser.deviceName().isEmpty()) {
-        m_deviceName = parser.deviceName();
-    } else {
+    if (m_qmlArgs.deviceName().isEmpty()) {
         char buffer[200];
         property_get("ro.product.device", buffer /* value */, "desktop" /* default_value*/);
-        m_deviceName = QString(buffer);
+        m_qmlArgs.setDeviceName(QString(buffer));
     }
-    m_qmlArgs.setDeviceName(m_deviceName);
-
-    m_qmlArgs.setMode(parser.mode());
 
     // The testability driver is only loaded by QApplication but not by QGuiApplication.
     // However, QApplication depends on QWidget which would add some unneeded overhead => Let's load the testability driver on our own.
-    if (parser.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {
+    if (m_qmlArgs.hasTestability() || getenv("QT_LOAD_TESTABILITY")) {
         QLibrary testLib(QStringLiteral("qttestability"));
         if (testLib.load()) {
             typedef void (*TasInitialize)(void);
@@ -75,26 +68,26 @@
     bindtextdomain("unity8", translationDirectory().toUtf8().data());
     textdomain("unity8");
 
-    m_shellView = new ShellView(m_qmlEngine, &m_qmlArgs);
-
-    if (parser.windowGeometry().isValid()) {
-        m_shellView->setWidth(parser.windowGeometry().width());
-        m_shellView->setHeight(parser.windowGeometry().height());
-    }
-
-    if (parser.hasFrameless()) {
-        m_shellView->setFlags(Qt::FramelessWindowHint);
-    }
-
+    m_qmlEngine->rootContext()->setContextProperty(QStringLiteral("applicationArguments"), &m_qmlArgs);
+
+    QByteArray pxpguEnv = qgetenv("GRID_UNIT_PX");
+    bool ok;
+    int pxpgu = pxpguEnv.toInt(&ok);
+    if (!ok) {
+        pxpgu = 8;
+    }
+    m_qmlEngine->rootContext()->setContextProperty("internalGu", pxpgu);
+    m_qmlEngine->load(::qmlDirectory() + "/ShellApplication.qml");
 
     #ifdef UNITY8_ENABLE_TOUCH_EMULATION
     // You will need this if you want to interact with touch-only components using a mouse
     // Needed only when manually testing on a desktop.
-    if (parser.hasMouseToTouch()) {
+    if (m_qmlArgs.hasMouseToTouch()) {
         m_mouseTouchAdaptor = MouseTouchAdaptor::instance();
     }
     #endif
 
+<<<<<<< TREE
     new DebuggingController(this);
 
     // Some hard-coded policy for now.
@@ -127,6 +120,22 @@
     } else {
         m_shellView->show();
     }
+=======
+//    if (parser.mode().compare("greeter") == 0) {
+//        QSize primaryScreenSize = this->primaryScreen()->size();
+//        m_shellView->setHeight(primaryScreenSize.height());
+//        m_shellView->setWidth(primaryScreenSize.width());
+//        m_shellView->show();
+//        m_shellView->requestActivate();
+//        if (!QProcess::startDetached("/sbin/initctl emit --no-wait unity8-greeter-started")) {
+//            qDebug() << "Unable to send unity8-greeter-started event to Upstart";
+//        }
+//    } else if (isMirServer || parser.hasFullscreen()) {
+//        m_shellView->showFullScreen();
+//    } else {
+//        m_shellView->show();
+//    }
+>>>>>>> MERGE-SOURCE
 }
 
 ShellApplication::~ShellApplication()
@@ -136,14 +145,6 @@
 
 void ShellApplication::destroyResources()
 {
-    // Deletion order is important. Don't use QScopedPointers and the like
-    // Otherwise the process will hang on shutdown (bug somewhere I guess).
-    delete m_shellView;
-    m_shellView = nullptr;
-
-    delete m_secondaryWindow;
-    m_secondaryWindow = nullptr;
-
     #ifdef UNITY8_ENABLE_TOUCH_EMULATION
     delete m_mouseTouchAdaptor;
     m_mouseTouchAdaptor = nullptr;
@@ -155,7 +156,7 @@
 
 void ShellApplication::setupQmlEngine(bool isMirServer)
 {
-    m_qmlEngine = new QQmlEngine(this);
+    m_qmlEngine = new QQmlApplicationEngine(this);
 
     m_qmlEngine->setBaseUrl(QUrl::fromLocalFile(::qmlDirectory()));
 
@@ -169,48 +170,3 @@
 
     QObject::connect(m_qmlEngine, &QQmlEngine::quit, this, &QGuiApplication::quit);
 }
-
-void ShellApplication::onScreenAdded(QScreen * /*screen*/)
-{
-    // TODO: Support an arbitrary number of screens and different policies
-    //       (eg cloned desktop, several desktops, etc)
-    if (screens().count() == 2) {
-        m_shellView->setScreen(screens().at(1));
-        m_qmlArgs.setDeviceName(QStringLiteral("desktop"));
-        // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having
-        // its backing QPlatformWindow recreated). So lets refocus it.
-        m_shellView->requestActivate();
-        // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again
-        // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/
-        m_shellView->setVisible(true);
-
-        m_secondaryWindow = new SecondaryWindow(m_qmlEngine);
-        m_secondaryWindow->setScreen(screens().at(0));
-
-        // QWindow::showFullScreen() also calls QWindow::requestActivate() and we don't want that!
-        m_secondaryWindow->setWindowState(Qt::WindowFullScreen);
-        m_secondaryWindow->setVisible(true);
-    }
-}
-
-void ShellApplication::onScreenAboutToBeRemoved(QScreen *screen)
-{
-    // TODO: Support an arbitrary number of screens and different policies
-    //       (eg cloned desktop, several desktops, etc)
-    if (screen == m_shellView->screen()) {
-        const QList<QScreen *> allScreens = screens();
-        Q_ASSERT(allScreens.count() > 1);
-        Q_ASSERT(allScreens.at(0) != screen);
-        Q_ASSERT(m_secondaryWindow);
-        delete m_secondaryWindow;
-        m_secondaryWindow = nullptr;
-        m_shellView->setScreen(allScreens.first());
-        m_qmlArgs.setDeviceName(m_deviceName);
-        // Changing the QScreen where a QWindow is drawn makes it also lose focus (besides having
-        // its backing QPlatformWindow recreated). So lets refocus it.
-        m_shellView->requestActivate();
-        // QWindow::destroy() is called when it changes between screens. We have to manually make it visible again
-        // <dandrader> This bug is supposedly fixed in Qt 5.5.1, although I can still reproduce it there. :-/
-        m_shellView->setVisible(true);
-    }
-}

=== modified file 'src/ShellApplication.h'
--- src/ShellApplication.h	2015-12-16 13:58:39 +0000
+++ src/ShellApplication.h	2017-01-16 11:35:19 +0000
@@ -18,7 +18,7 @@
 #define SHELLAPPLICATION_H
 
 #include <QGuiApplication>
-#include <QQmlEngine>
+#include <QQmlApplicationEngine>
 #include <QQuickView>
 #include <QScopedPointer>
 
@@ -28,9 +28,6 @@
 #include "MouseTouchAdaptor.h"
 #endif
 
-#include "SecondaryWindow.h"
-#include "ShellView.h"
-
 class ShellApplication : public QGuiApplication
 {
     Q_OBJECT
@@ -39,25 +36,16 @@
     virtual ~ShellApplication();
 
     void destroyResources();
-public Q_SLOTS:
-    // called by qtmir
-    void onScreenAboutToBeRemoved(QScreen *screen);
-
-private Q_SLOTS:
-    void onScreenAdded(QScreen*);
 
 private:
     void setupQmlEngine(bool isMirServer);
-    QString m_deviceName;
     ApplicationArguments m_qmlArgs;
-    ShellView *m_shellView{nullptr};
-    SecondaryWindow *m_secondaryWindow{nullptr};
 
     #ifdef UNITY8_ENABLE_TOUCH_EMULATION
     MouseTouchAdaptor *m_mouseTouchAdaptor{nullptr};
     #endif
 
-    QQmlEngine *m_qmlEngine{nullptr};
+    QQmlApplicationEngine *m_qmlEngine{nullptr};
 };
 
 #endif // SHELLAPPLICATION_H

=== removed file 'src/ShellView.cpp'
--- src/ShellView.cpp	2016-03-22 14:09:28 +0000
+++ src/ShellView.cpp	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*
- * 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/>.
- */
-
-#include "ShellView.h"
-
-// Qt
-#include <QQmlContext>
-#include <QQuickItem>
-
-// local
-#include <paths.h>
-
-ShellView::ShellView(QQmlEngine *engine, QObject *qmlArgs)
-    : QQuickView(engine, nullptr)
-{
-    setResizeMode(QQuickView::SizeRootObjectToView);
-    setColor("black");
-    setTitle(QStringLiteral("Unity8"));
-
-    rootContext()->setContextProperty(QStringLiteral("applicationArguments"), qmlArgs);
-
-    QUrl source(::qmlDirectory() + "/OrientedShell.qml");
-    setSource(source);
-
-    connect(this, &QWindow::widthChanged, this, &ShellView::onWidthChanged);
-    connect(this, &QWindow::heightChanged, this, &ShellView::onHeightChanged);
-}
-
-void ShellView::onWidthChanged(int w)
-{
-    // For good measure in case SizeRootObjectToView doesn't fulfill its promise.
-    //
-    // There's at least one situation that's know to leave the root object with an outdated size.
-    // (really looks like Qt bug)
-    // Happens when starting unity8 with an external monitor already connected.
-    // The QResizeEvent we get still has the size of the first screen and since the resize move is triggered
-    // from the resize event handler, the root item doesn't get resized.
-    // TODO: Confirm the Qt bug and submit a patch upstream
-    if (rootObject()) {
-        rootObject()->setWidth(w);
-    }
-}
-
-void ShellView::onHeightChanged(int h)
-{
-    // See comment in ShellView::onWidthChanged()
-    if (rootObject()) {
-        rootObject()->setHeight(h);
-    }
-}

=== removed file 'src/ShellView.h'
--- src/ShellView.h	2015-10-16 16:56:14 +0000
+++ src/ShellView.h	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef UNITY_SHELL_VIEW_H
-#define UNITY_SHELL_VIEW_H
-
-#include <QQuickView>
-
-class ShellView : public QQuickView
-{
-    Q_OBJECT
-
-public:
-    ShellView(QQmlEngine *engine, QObject *qmlArgs);
-
-private Q_SLOTS:
-    void onWidthChanged(int);
-    void onHeightChanged(int);
-};
-
-#endif // UNITY_SHELL_VIEW_H

=== modified file 'src/UnityCommandLineParser.h'
--- src/UnityCommandLineParser.h	2015-12-16 13:58:39 +0000
+++ src/UnityCommandLineParser.h	2017-01-16 11:35:19 +0000
@@ -36,8 +36,8 @@
     bool hasFullscreen() const { return m_hasFullscreen; }
     QString deviceName() const { return m_deviceName; }
     QString mode() const { return m_mode; }
-private:
 
+protected:
     int parsePixelsValue(const QString &str);
     static float getenvFloat(const char* name, float defaultValue);
     void resolveMode(QCommandLineParser &parser, QCommandLineOption &modeOption);

=== modified file 'tests/mocks/Cursor/Cursor.qml'
--- tests/mocks/Cursor/Cursor.qml	2016-10-03 11:15:27 +0000
+++ tests/mocks/Cursor/Cursor.qml	2017-01-16 11:35:19 +0000
@@ -15,8 +15,11 @@
  */
 
 import QtQuick 2.4
-
-Item {
+import UInput 0.1
+
+Canvas {
+    id: root
+
     property int topBoundaryOffset // effectively panel height
     property Item confiningItem
 
@@ -30,5 +33,50 @@
     signal pushStopped()
     signal mouseMoved()
 
-    onMouseMoved: opacity = 1;
+    width: units.gu(2)
+    height: units.gu(2)
+    antialiasing: true
+
+    onPaint: {
+        var ctx = getContext("2d");
+        ctx.save();
+        ctx.clearRect(0,0,width, height);
+        ctx.strokeStyle = "#000000";
+        ctx.lineWidth = 1
+        ctx.fillStyle = "#ffffff";
+        ctx.globalAlpha = 1.0;
+        ctx.lineJoin = "round";
+        ctx.beginPath();
+
+        // put rectangle in the middle
+        // draw the rectangle
+        ctx.moveTo(width/2,height);
+        ctx.lineTo(width, height/2);
+        ctx.lineTo(0,0);
+
+        ctx.closePath();
+        ctx.fill();
+        ctx.stroke();
+        ctx.restore();
+    }
+
+    Connections {
+        target: UInput
+        onMouseMoved: {
+            var newX = root.x;
+            newX += dx;
+            if (newX < 0) newX = 0;
+            else if (newX >= parent.width) newX = parent.width-1;
+
+            var newY = root.y;
+            newY += dy;
+            if (newY < 0) newY = 0;
+            else if (newY >= parent.height) newY = parent.height-1;
+
+            root.x = newX;
+            root.y = newY;
+            root.mouseMoved();
+        }
+    }
 }
+

=== modified file 'tests/mocks/GSettings.1.0/plugin.cpp'
--- tests/mocks/GSettings.1.0/plugin.cpp	2015-04-15 14:09:06 +0000
+++ tests/mocks/GSettings.1.0/plugin.cpp	2017-01-16 11:35:19 +0000
@@ -18,6 +18,8 @@
 #include "fake_gsettings.h"
 
 #include <QtQml/qqml.h>
+#include <QQmlEngine>
+#include <QQmlContext>
 
 static QObject* controllerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
 {
@@ -31,3 +33,13 @@
     qmlRegisterUncreatableType<GSettingsSchemaQml>(uri, 1, 0, "GSettingsSchema",
                                                    "GSettingsSchema can only be used inside of a GSettings component");
 }
+
+void FakeGSettingsQmlPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+{
+    QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    QString usageType = qgetenv("UNITY_MOCK_DESKTOP");
+    if (!usageType.isEmpty()) {
+        GSettingsControllerQml::instance()->setUsageMode("Windowed");
+    }
+}

=== modified file 'tests/mocks/GSettings.1.0/plugin.h'
--- tests/mocks/GSettings.1.0/plugin.h	2015-04-30 09:31:51 +0000
+++ tests/mocks/GSettings.1.0/plugin.h	2017-01-16 11:35:19 +0000
@@ -26,6 +26,7 @@
 
 public:
     void registerTypes(const char *uri) override;
+    void initializeEngine(QQmlEngine *engine, const char *uri) override;
 };
 
 #endif // PLUGIN_H

=== modified file 'tests/mocks/UInput/plugin.cpp'
--- tests/mocks/UInput/plugin.cpp	2015-11-23 16:50:26 +0000
+++ tests/mocks/UInput/plugin.cpp	2017-01-16 11:35:19 +0000
@@ -19,8 +19,13 @@
 
 #include <QtQml/qqml.h>
 
+QObject* uinputSingleton(QQmlEngine*, QJSEngine*)
+{
+    return new MockUInput;
+}
+
 void MockUInputPlugin::registerTypes(const char *uri)
 {
     Q_ASSERT(uri == QLatin1String("UInput"));
-    qmlRegisterType<MockUInput>(uri, 0, 1, "UInput");
+    qmlRegisterSingletonType<MockUInput>(uri, 0, 1, "UInput", uinputSingleton);
 }

=== modified file 'tests/mocks/Unity/Application/MirSurfaceItem.cpp'
--- tests/mocks/Unity/Application/MirSurfaceItem.cpp	2016-12-23 11:05:09 +0000
+++ tests/mocks/Unity/Application/MirSurfaceItem.cpp	2017-01-16 11:35:19 +0000
@@ -293,6 +293,10 @@
         connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);
         connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);
         connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);
+        connect(m_qmlSurface, &MirSurface::sizeChanged, this, [this] () {
+            m_qmlItem->setSize(m_qmlSurface->size());
+            setImplicitSize(m_qmlSurface->width(), m_qmlSurface->height());
+        });
 
         QUrl qmlComponentFilePath;
         if (!m_qmlSurface->qmlFilePath().isEmpty()) {
@@ -387,6 +391,7 @@
             m_qmlItem->setWidth(m_surfaceWidth);
             m_qmlItem->setHeight(m_surfaceHeight);
         }
+        qDebug() << this << "setting implicitsize" << m_surfaceWidth << m_surfaceHeight;
         setImplicitSize(m_surfaceWidth, m_surfaceHeight);
     }
 }

=== modified file 'tests/mocks/Unity/Application/SurfaceManager.cpp'
--- tests/mocks/Unity/Application/SurfaceManager.cpp	2017-01-03 12:45:42 +0000
+++ tests/mocks/Unity/Application/SurfaceManager.cpp	2017-01-16 11:35:19 +0000
@@ -21,7 +21,7 @@
 
 #include <paths.h>
 
-#define SURFACEMANAGER_DEBUG 0
+#define SURFACEMANAGER_DEBUG 1
 
 #if SURFACEMANAGER_DEBUG
 #define DEBUG_MSG(params) qDebug().nospace() << "SurfaceManager[" << (void*)this << "]::" << __func__  << params

=== added file 'tests/mocks/Unity/InputInfo/InputWindow.qml'
--- tests/mocks/Unity/InputInfo/InputWindow.qml	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/InputInfo/InputWindow.qml	2017-01-16 11:35:19 +0000
@@ -0,0 +1,68 @@
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+import Unity.InputInfo 0.1
+
+Rectangle {
+    id: rect
+    color: "white"
+    width: parent.width
+    height: parent.height
+
+    Action {
+        id: mouseAction
+        text: checked ? "Remove Mouse" : "Add Mouse"
+        onTriggered: {
+            if (checked) {
+                console.log("ADD")
+                MockInputDeviceBackend.addMockDevice("/mouse0", InputInfo.Mouse);
+            } else {
+                console.log("REMOVE")
+                MockInputDeviceBackend.removeDevice("/mouse0");
+            }
+        }
+        iconName: "input-mouse-symbolic"
+        checkable: true
+        checked: false
+    }
+
+    Action {
+        id: kbAction
+        text: checked ? "Remove Keyboard" : "Add Keyboard"
+        onTriggered: {
+            if (checked) {
+                MockInputDeviceBackend.addMockDevice("/kbd0", InputInfo.Keyboard);
+            } else {
+                MockInputDeviceBackend.removeDevice("/kbd0");
+            }
+        }
+        iconName: "input-keyboard-symbolic"
+        checkable: true
+        checked: false
+    }
+
+    Column {
+        anchors {
+            fill: parent
+            margins: units.gu(1)
+        }
+        spacing: units.gu(1)
+
+        Button {
+            anchors {
+                left: parent.left
+                right: parent.right
+            }
+            action: mouseAction
+            color: mouseAction.checked ? UbuntuColors.red : UbuntuColors.green
+        }
+
+        Button {
+            anchors {
+                left: parent.left
+                right: parent.right
+            }
+            action: kbAction
+            color: kbAction.checked ? UbuntuColors.red : UbuntuColors.green
+        }
+    }
+}

=== modified file 'tests/mocks/Unity/InputInfo/mockcontroller.cpp'
--- tests/mocks/Unity/InputInfo/mockcontroller.cpp	2015-11-09 09:23:23 +0000
+++ tests/mocks/Unity/InputInfo/mockcontroller.cpp	2017-01-16 11:35:19 +0000
@@ -18,10 +18,32 @@
 
 #include "qinputdeviceinfo_mock_p.h"
 
-MockController::MockController(QObject *parent):
-    QObject(parent)
-{
-
+#include <QQuickView>
+#include <QQmlComponent>
+#include <QQuickItem>
+#include <paths.h>
+
+MockController::MockController(QQmlEngine *engine)
+{
+    QQmlComponent component(engine);
+    component.setData("import QtQuick 2.4; import Unity.InputInfo 0.1; InputWindow { }", ::qmlDirectory());
+    QObject *myObject = component.create();
+    QQuickItem *item = qobject_cast<QQuickItem*>(myObject);
+    if (item) {
+        auto window = new QQuickView();
+        window->setTitle("Input");
+        item->setParentItem(window->contentItem());
+        window->setResizeMode(QQuickView::SizeRootObjectToView);
+        window->setWidth(200);
+        window->setHeight(100);
+        window->show();
+    }
+}
+
+MockController *MockController::instance(QQmlEngine *engine)
+{
+    static MockController* controller = new MockController(engine);
+    return controller;
 }
 
 QInputDevice *MockController::addMockDevice(const QString &devicePath, QInputDevice::InputType type)

=== modified file 'tests/mocks/Unity/InputInfo/mockcontroller.h'
--- tests/mocks/Unity/InputInfo/mockcontroller.h	2015-11-02 15:55:58 +0000
+++ tests/mocks/Unity/InputInfo/mockcontroller.h	2017-01-16 11:35:19 +0000
@@ -20,13 +20,17 @@
 #include <QObject>
 #include "qinputinfo.h"
 
+class QQmlEngine;
+
 class MockController: public QObject
 {
     Q_OBJECT
 public:
-    MockController(QObject *parent = 0);
+    MockController(QQmlEngine *engine);
     ~MockController() = default;
 
+    static MockController *instance(QQmlEngine *engine);
+
     Q_INVOKABLE QInputDevice* addMockDevice(const QString &devicePath, QInputDevice::InputType type);
     Q_INVOKABLE void removeDevice(const QString &devicePath);
 };

=== modified file 'tests/mocks/Unity/InputInfo/plugin.cpp'
--- tests/mocks/Unity/InputInfo/plugin.cpp	2015-11-02 15:55:58 +0000
+++ tests/mocks/Unity/InputInfo/plugin.cpp	2017-01-16 11:35:19 +0000
@@ -26,9 +26,8 @@
 
 static QObject *backendProvider(QQmlEngine *engine, QJSEngine *scriptEngine)
 {
-    Q_UNUSED(engine)
     Q_UNUSED(scriptEngine)
-    return new MockController(engine);
+    return MockController::instance(engine);
 }
 
 void InputInfoPlugin::registerTypes(const char *uri)

=== modified file 'tests/mocks/Unity/InputInfo/qmldir'
--- tests/mocks/Unity/InputInfo/qmldir	2015-06-23 14:20:46 +0000
+++ tests/mocks/Unity/InputInfo/qmldir	2017-01-16 11:35:19 +0000
@@ -1,2 +1,4 @@
 module Unity.InputInfo
 plugin MockInputInfo
+
+InputWindow 0.1 InputWindow.qml

=== modified file 'tests/mocks/Unity/Screens/CMakeLists.txt'
--- tests/mocks/Unity/Screens/CMakeLists.txt	2016-10-25 10:10:08 +0000
+++ tests/mocks/Unity/Screens/CMakeLists.txt	2017-01-16 11:35:19 +0000
@@ -5,10 +5,11 @@
 set(MockScreens_SOURCES
     plugin.cpp
     screens.cpp
+    screenwindow.cpp
 )
 
 add_library(MockScreensPlugin MODULE ${MockScreens_SOURCES})
 
-qt5_use_modules(MockScreensPlugin Gui Qml)
+qt5_use_modules(MockScreensPlugin Gui Qml Quick)
 
 add_unity8_mock(Unity.Screens 0.1 Unity/Screens PREFIX mocks TARGETS MockScreensPlugin)

=== modified file 'tests/mocks/Unity/Screens/plugin.cpp'
--- tests/mocks/Unity/Screens/plugin.cpp	2015-12-02 13:23:45 +0000
+++ tests/mocks/Unity/Screens/plugin.cpp	2017-01-16 11:35:19 +0000
@@ -16,14 +16,25 @@
 
 #include "plugin.h"
 #include "screens.h"
+#include "screenwindow.h"
 
 #include <QScreen>
 
+namespace {
+QObject* screensSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
+    Q_UNUSED(engine);
+    Q_UNUSED(scriptEngine);
+    return new Screens();
+}
+}
+
 void UnityScreensPlugin::registerTypes(const char* uri)
 {
     Q_ASSERT(QLatin1String(uri) == QLatin1String("Unity.Screens"));
 
     qRegisterMetaType<QScreen*>("QScreen*");
 
-    qmlRegisterType<Screens>(uri, 0, 1, "Screens");
+    qmlRegisterSingletonType<Screens>(uri, 0, 1, "Screens", screensSingleton);
+    qmlRegisterType<ScreenWindow>(uri, 0, 1, "ScreenWindow");
+    qmlRegisterRevision<QWindow,1>(uri, 0, 1);
 }

=== modified file 'tests/mocks/Unity/Screens/screens.cpp'
--- tests/mocks/Unity/Screens/screens.cpp	2016-12-23 11:04:53 +0000
+++ tests/mocks/Unity/Screens/screens.cpp	2017-01-16 11:35:19 +0000
@@ -26,8 +26,20 @@
 Screens::Screens(QObject *parent) :
     QAbstractListModel(parent)
 {
-    // start with one screen attached
-    m_screenList.append(new Screen());
+    bool ok = false;
+    int screenCount = qEnvironmentVariableIntValue("UNITY_MOCK_SCREEN_COUNT", &ok);
+    if (!ok) screenCount = 1;
+    QPoint lastPoint(0,0);
+    for (int i = 0; i < screenCount; ++i) {
+        auto screen = new Screen();
+        screen->enabled = i == 0;
+        screen->name = QString("Monitor %1").arg(i);
+        screen->sizes = { QSize(640,480), QSize(1024,748), QSize(1280,1024), QSize(1440,900), QSize(1920,1080) };
+        screen->geometry = QRect(lastPoint.x(), lastPoint.y(), 1024, 786 );
+        m_screenList.append(screen);
+
+        lastPoint.rx() += screen->geometry.width();
+    }
 }
 
 Screens::~Screens() noexcept
@@ -41,6 +53,12 @@
     QHash<int, QByteArray> roles;
     roles[ScreenRole] = "screen";
     roles[OutputTypeRole] = "outputType";
+    roles[EnabledRole] = "enabled";
+    roles[NameRole] = "name";
+    roles[ScaleRole] = "scale";
+    roles[FormFactorRole] = "formFactor";
+    roles[GeometryRole] = "geometry";
+    roles[SizesRole] = "sizes";
     return roles;
 }
 
@@ -52,9 +70,29 @@
 
     switch(role) {
     case ScreenRole:
+        qDebug() << "returning" << m_screenList.at(index.row())->qScreen;
         return QVariant::fromValue(m_screenList.at(index.row())->qScreen);
     case OutputTypeRole:
         return m_screenList.at(index.row())->outputTypes;
+    case EnabledRole:
+        return m_screenList.at(index.row())->enabled;
+    case NameRole:
+        return m_screenList.at(index.row())->name;
+    case ScaleRole:
+        return m_screenList.at(index.row())->scale;
+    case FormFactorRole:
+        return m_screenList.at(index.row())->formFactor;
+    case GeometryRole:
+        return m_screenList.at(index.row())->geometry;
+    case SizesRole:
+        {
+            QVariantList sizes;
+            auto availableSizes = m_screenList.at(index.row())->sizes;
+            Q_FOREACH(auto size, availableSizes) {
+                sizes.append(QVariant(size));
+            }
+            return sizes;
+        }
     }
 
     return QVariant();

=== modified file 'tests/mocks/Unity/Screens/screens.h'
--- tests/mocks/Unity/Screens/screens.h	2016-12-23 11:04:53 +0000
+++ tests/mocks/Unity/Screens/screens.h	2017-01-16 11:35:19 +0000
@@ -25,13 +25,24 @@
 class Screens : public QAbstractListModel
 {
     Q_OBJECT
+<<<<<<< TREE
+=======
+    Q_ENUMS(OutputTypes)
+    Q_ENUMS(FormFactor)
+>>>>>>> MERGE-SOURCE
 
     Q_PROPERTY(int count READ count NOTIFY countChanged)
 
 public:
     enum ItemRoles {
         ScreenRole = Qt::UserRole + 1,
-        OutputTypeRole
+        OutputTypeRole,
+        EnabledRole,
+        NameRole,
+        ScaleRole,
+        FormFactorRole,
+        GeometryRole,
+        SizesRole
     };
 
     enum OutputTypes {
@@ -53,6 +64,15 @@
     };
     Q_ENUM(OutputTypes)
 
+    enum FormFactor {
+        FormFactorUnknown,
+        FormFactorPhone,
+        FormFactorTablet,
+        FormFactorMonitor,
+        FormFactorTV,
+        FormFactorProjector,
+    };
+
     explicit Screens(QObject *parent = 0);
     virtual ~Screens() noexcept;
 
@@ -77,6 +97,12 @@
 public:
     Screens::OutputTypes outputTypes = Screens::Unknown;
     QScreen *qScreen = nullptr;
+    bool enabled = false;
+    QString name = QString();
+    float scale = 1.0;
+    Screens::FormFactor formFactor = Screens::FormFactorMonitor;
+    QRect geometry;
+    QList<QSize> sizes;
 };
 
 #endif // SCREENS_H

=== added file 'tests/mocks/Unity/Screens/screenwindow.cpp'
--- tests/mocks/Unity/Screens/screenwindow.cpp	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/Screens/screenwindow.cpp	2017-01-16 11:35:19 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "screenwindow.h"
+
+ScreenWindow::ScreenWindow(QWindow *parent)
+    : QQuickWindow(parent)
+{
+}
+
+QScreen *ScreenWindow::screen() const
+{
+    return QQuickWindow::screen();
+}
+
+void ScreenWindow::setScreen(QScreen *screen)
+{
+    QQuickWindow::setScreen(screen);
+}

=== added file 'tests/mocks/Unity/Screens/screenwindow.h'
--- tests/mocks/Unity/Screens/screenwindow.h	1970-01-01 00:00:00 +0000
+++ tests/mocks/Unity/Screens/screenwindow.h	2017-01-16 11:35:19 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SCREENWINDOW_H
+#define SCREENWINDOW_H
+
+#include <QQuickWindow>
+
+class ScreenWindow : public QQuickWindow
+{
+    Q_OBJECT
+    Q_PROPERTY(QScreen *screen READ screen WRITE setScreen NOTIFY screenChanged)
+public:
+    ScreenWindow(QWindow *parent = 0);
+
+    QScreen *screen() const;
+    void setScreen(QScreen *screen);
+
+Q_SIGNALS:
+    void screenChanged(QScreen *screen);
+};
+
+#endif // SCREENWINDOW_H

=== modified file 'tests/qmltests/Components/tst_VirtualTouchPad.qml'
--- tests/qmltests/Components/tst_VirtualTouchPad.qml	2016-12-05 11:17:15 +0000
+++ tests/qmltests/Components/tst_VirtualTouchPad.qml	2017-01-16 11:35:19 +0000
@@ -39,11 +39,11 @@
 
     SignalSpy {
         id: mouseEventSpy1
-        target: touchScreenPad.uinput
+        target: UInput
     }
     SignalSpy {
         id: mouseEventSpy2
-        target: touchScreenPad.uinput
+        target: UInput
     }
 
     UnityTestCase {

=== modified file 'tests/qmltests/Panel/tst_Panel.qml'
--- tests/qmltests/Panel/tst_Panel.qml	2017-01-10 13:50:27 +0000
+++ tests/qmltests/Panel/tst_Panel.qml	2017-01-16 11:35:19 +0000
@@ -26,9 +26,12 @@
 import AccountsService 0.1
 import Unity.InputInfo 0.1
 import "../../../qml/Panel"
+<<<<<<< TREE
 import "../../../qml/Components/PanelState"
 import "../Stage"
 import ".."
+=======
+>>>>>>> MERGE-SOURCE
 
 PanelTest {
     id: root
@@ -36,6 +39,15 @@
     height: units.gu(71)
     color: "black"
 
+<<<<<<< TREE
+=======
+    Component.onCompleted: theme.name = "Ubuntu.Components.Themes.SuruDark"
+
+    readonly property alias panelState: panel.panelState
+
+    SurfaceManager {}
+
+>>>>>>> MERGE-SOURCE
     Binding {
         target: QuickUtils
         property: "keyboardAttached"
@@ -148,7 +160,11 @@
                 Layout.fillWidth: true
                 CheckBox {
                     id: windowControlsCB
+<<<<<<< TREE
                     onClicked: PanelState.decorationsVisible = checked
+=======
+                    onClicked: panelState.buttonsVisible = checked
+>>>>>>> MERGE-SOURCE
                 }
                 Label {
                     text: "Show window decorations"
@@ -159,7 +175,16 @@
             RowLayout {
                 Layout.fillWidth: true
                 CheckBox {
+<<<<<<< TREE
                     onClicked: PanelState.title = checked ? "Fake window title" : ""
+=======
+                    onClicked: {
+                        if (checked)
+                            panelState.title = "Fake window title"
+                        else
+                            panelState.title = ""
+                    }
+>>>>>>> MERGE-SOURCE
                 }
                 Label {
                     text: "Show fake window title"
@@ -245,7 +270,7 @@
 
         SignalSpy {
             id: windowControlButtonsSpy
-            target: PanelState
+            target: panelState
             signalName: "closeClicked"
         }
 
@@ -695,15 +720,21 @@
 
         // https://bugs.launchpad.net/ubuntu/+source/unity8/+bug/1611959
         function test_windowControlButtonsFittsLaw() {
+<<<<<<< TREE
             panel.mode = "windowed";
             var windowControlArea = findChild(panel, "windowControlArea");
             verify(windowControlArea, "Window control area should have been created in windowed mode")
 
             PanelState.decorationsVisible = true;
+=======
+            var buttonsVisible = panelState.buttonsVisible;
+            panelState.buttonsVisible = true;
+>>>>>>> MERGE-SOURCE
             // click in very topleft corner and verify the close button got clicked too
             mouseMove(panel, 0, 0);
             mouseClick(panel, 0, 0, undefined /*button*/, undefined /*modifiers*/, 100 /*short delay*/);
             compare(windowControlButtonsSpy.count, 1);
+<<<<<<< TREE
         }
 
         function test_hidingKeyboardIndicator_data() {
@@ -798,6 +829,9 @@
 
             tryCompare(appTitle, "visible", false, undefined, "App title should still be visible on mouse hover when panel decorations are visible");
             tryCompare(appMenuBar, "visible", true, undefined, "App menu bar should be visible on mouse hover when panel decorations not visible");
+=======
+            panelState.buttonsVisible = buttonsVisible;
+>>>>>>> MERGE-SOURCE
         }
     }
 }

=== modified file 'tests/qmltests/Stage/tst_DesktopStage.qml'
--- tests/qmltests/Stage/tst_DesktopStage.qml	2017-01-10 14:44:29 +0000
+++ tests/qmltests/Stage/tst_DesktopStage.qml	2017-01-16 11:35:19 +0000
@@ -43,6 +43,10 @@
         value: false
     }
 
+    PanelState {
+        id: panelState
+    }
+
     Component.onCompleted: {
         QuickUtils.keyboardAttached = true;
         theme.name = "Ubuntu.Components.Themes.SuruDark";
@@ -100,6 +104,7 @@
                 topLevelSurfaceList: topSurfaceList
                 interactive: true
                 mode: "windowed"
+                panelState: panelState
             }
         }
     }
@@ -618,19 +623,19 @@
             maximizeDelegate(facebookAppDelegate);
 
             // verify the drop shadow is still not visible
-            verify(PanelState.dropShadow == false);
+            verify(panelState.dropShadow == false);
 
             // start a foreground app, not maximized
             var dialerAppDelegate = startApplication("dialer-app");
 
             // verify the drop shadow becomes visible
-            verify(PanelState.dropShadow == true);
+            verify(panelState.dropShadow == true);
 
             // close the maximized app
             ApplicationManager.stopApplication("facebook-webapp");
 
             // verify the drop shadow is gone
-            tryCompare(PanelState, "dropShadow", false);
+            tryCompare(panelState, "dropShadow", false);
         }
 
         function test_threeFingerTapShowsWindowControls_data() {

=== modified file 'tests/qmltests/Stage/tst_WindowResizeArea.qml'
--- tests/qmltests/Stage/tst_WindowResizeArea.qml	2016-12-21 16:20:58 +0000
+++ tests/qmltests/Stage/tst_WindowResizeArea.qml	2017-01-16 11:35:19 +0000
@@ -19,7 +19,6 @@
 import QtTest 1.0
 import Unity.Test 0.1
 import ".."
-import "../../../qml/Components/PanelState"
 import "../../../qml/Stage"
 import Ubuntu.Components 1.3
 import Ubuntu.Components.ListItems 1.3 as ListItem
@@ -31,12 +30,6 @@
     height: units.gu(60)
     width: units.gu(85)
 
-    Binding {
-        target: PanelState
-        property: "panelHeight"
-        value: units.gu(3)
-    }
-
     Component {
         id: fakeWindowComponent
 
@@ -352,7 +345,7 @@
 
             // Make sure it's again where we left it in normal state before destroying
             compare(fakeWindow.requestedX >= 0, true)
-            compare(fakeWindow.requestedY >= PanelState.panelHeight, true)
+            compare(fakeWindow.requestedY >= 0, true)
             compare(fakeWindow.requestedX + fakeWindow.width <= root.width, true)
             compare(fakeWindow.requestedY + fakeWindow.height <= root.height, true)
 

=== modified file 'tests/qmltests/tst_OrientedShell.qml'
--- tests/qmltests/tst_OrientedShell.qml	2016-12-12 16:45:09 +0000
+++ tests/qmltests/tst_OrientedShell.qml	2017-01-16 11:35:19 +0000
@@ -29,7 +29,6 @@
 
 import "../../qml"
 import "../../qml/Components"
-import "../../qml/Components/PanelState"
 import "Stage"
 
 Rectangle {
@@ -75,6 +74,12 @@
         deviceFilter: InputInfo.Keyboard
     }
 
+    QtObject {
+        id: _screenWindow
+        property bool primary: true
+    }
+    property alias screenWindow: _screenWindow
+
     property int physicalOrientation0
     property int physicalOrientation90
     property int physicalOrientation180
@@ -167,6 +172,11 @@
                 Component.onDestruction: {
                     orientedShellLoader.itemDestroyed = true;
                 }
+
+                SurfaceManager {
+                    id: surfaceMan
+                }
+                surfaceManager: surfaceMan
             }
         }
     }
@@ -439,6 +449,15 @@
         property Item orientedShell: orientedShellLoader.status === Loader.Ready ? orientedShellLoader.item : null
         property Item shell
         property QtObject topLevelSurfaceList
+        property var panelState: undefined
+
+        onOrientedShellChanged: {
+            if (orientedShell) {
+                panelState = findInvisibleChild(orientedShell, "panelState");
+            } else {
+                panelState = undefined;
+            }
+        }
 
         SignalSpy { id: signalSpy }
         SignalSpy { id: signalSpy2 }
@@ -1507,13 +1526,13 @@
             print("exptectedAngle", expectedAngle, point.x, point.y)
             switch (expectedAngle) {
             case 0:
-                return point.x === 0 && point.y === PanelState.panelHeight;
+                return point.x === 0 && point.y === panelState.panelHeight;
             case 90:
-                return point.x === orientedShell.width - PanelState.panelHeight && point.y === 0;
+                return point.x === orientedShell.width - panelState.panelHeight && point.y === 0;
             case 180:
-                return point.x === orientedShell.width && point.y === orientedShell.height - PanelState.panelHeight;
+                return point.x === orientedShell.width && point.y === orientedShell.height - panelState.panelHeight;
             default: // 270
-                return point.x === PanelState.panelHeight && point.y === orientedShell.height;
+                return point.x === panelState.panelHeight && point.y === orientedShell.height;
             }
         }
 

=== modified file 'tests/qmltests/tst_Shell.qml'
--- tests/qmltests/tst_Shell.qml	2017-01-09 14:10:17 +0000
+++ tests/qmltests/tst_Shell.qml	2017-01-16 11:35:19 +0000
@@ -61,14 +61,29 @@
     onShellChanged: {
         if (shell) {
             topLevelSurfaceList = testCase.findInvisibleChild(shell, "topLevelSurfaceList");
+<<<<<<< TREE
             appMenuData.surfaceManager = testCase.findInvisibleChild(shell, "surfaceManager");
+=======
+            panelState = testCase.findInvisibleChild(shell, "panelState");
+>>>>>>> MERGE-SOURCE
         } else {
             topLevelSurfaceList = null;
+<<<<<<< TREE
             appMenuData.surfaceManager = null;
+=======
+            panelState = undefined;
+>>>>>>> MERGE-SOURCE
         }
     }
 
     property var topLevelSurfaceList: null
+    property var panelState: undefined
+
+    QtObject {
+        id: _screenWindow
+        property bool primary: false
+    }
+    property alias screenWindow: _screenWindow
 
     Item {
         id: shellContainer
@@ -143,6 +158,11 @@
                     Component.onDestruction: {
                         shellLoader.itemDestroyed = true;
                     }
+
+                    SurfaceManager {
+                        id: surfaceMan
+                    }
+                    surfaceManager: surfaceMan
                 }
             }
         }
@@ -679,7 +699,7 @@
         }
 
         function ensureInputMethodSurface() {
-            var surfaceManager = findInvisibleChild(shell, "surfaceManager");
+            var surfaceManager = shell.surfaceManager;
             verify(surfaceManager);
             surfaceManager.createInputMethodSurface();
 
@@ -1886,21 +1906,37 @@
             var maximizeButton = findChild(appDelegate, "maximizeWindowButton");
 
             tryCompare(appDelegate, "state", "normal");
+<<<<<<< TREE
             tryCompare(PanelState, "decorationsVisible", false)
+=======
+            tryCompare(panelState, "buttonsVisible", false)
+>>>>>>> MERGE-SOURCE
 
             mouseClick(maximizeButton, maximizeButton.width / 2, maximizeButton.height / 2);
             tryCompare(appDelegate, "state", "maximized");
+<<<<<<< TREE
             tryCompare(PanelState, "decorationsVisible", true)
+=======
+            tryCompare(panelState, "buttonsVisible", true)
+>>>>>>> MERGE-SOURCE
 
             ApplicationManager.stopApplication(application.appId);
+<<<<<<< TREE
             tryCompare(PanelState, "decorationsVisible", false)
+=======
+            tryCompare(panelState, "buttonsVisible", false)
+>>>>>>> MERGE-SOURCE
 
             // wait until all zombie surfaces are gone. As MirSurfaceItems hold references over them.
             // They won't be gone until those surface items are destroyed.
             tryCompareFunction(function() { return application.surfaceList.count }, 0);
 
             ApplicationManager.startApplication(application.appId);
+<<<<<<< TREE
             tryCompare(PanelState, "decorationsVisible", true)
+=======
+            tryCompare(panelState, "buttonsVisible", true)
+>>>>>>> MERGE-SOURCE
         }
 
         function test_newAppHasValidGeometry() {
@@ -1957,7 +1993,7 @@
             mousePress(appDelegate, appDelegate.width / 2, units.gu(1))
             mouseMove(appDelegate, appDelegate.width / 2, -units.gu(100))
 
-            compare(appDelegate.y >= PanelState.panelHeight, true);
+            compare(appDelegate.y >= panelState.panelHeight, true);
         }
 
         function test_cantResizeWindowUnderPanel() {
@@ -1985,7 +2021,7 @@
             mouseMove(decoration, decoration.width/2, -units.gu(100));
 
             // verify we don't go past the panel
-            compare(appDelegate.y >= PanelState.panelHeight, true);
+            compare(appDelegate.y >= panelState.panelHeight, true);
         }
 
         function test_restoreWindowStateFixesIfUnderPanel() {
@@ -2009,7 +2045,7 @@
             tryCompareFunction(function () { return topLevelSurfaceList.applicationAt(0).appId; }, application.appId);
 
             appDelegate = appRepeater.itemAt(0);
-            compare(appDelegate.y >= PanelState.panelHeight, true);
+            compare(appDelegate.y >= panelState.panelHeight, true);
         }
 
         function test_lifecyclePolicyForNonTouchApp_data() {
@@ -2610,7 +2646,7 @@
         function test_oskDisplacesWindow_data() {
             return [
                 {tag: "no need to displace", windowHeight: units.gu(10), windowY: units.gu(5), targetDisplacement: units.gu(5), oskEnabled: true},
-                {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: PanelState.panelHeight, oskEnabled: true},
+                {tag: "displace to top", windowHeight: units.gu(50), windowY: units.gu(10), targetDisplacement: panelState.panelHeight, oskEnabled: true},
                 {tag: "osk not on this screen", windowHeight: units.gu(40), windowY: units.gu(10), targetDisplacement: units.gu(10), oskEnabled: false},
             ]
         }
@@ -2633,8 +2669,8 @@
             dashAppDelegate.windowedY = data.windowY;
             topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, 0, 0, 0));
             var initialY = dashAppDelegate.y;
-            print("intial", initialY, "panel", PanelState.panelHeight);
-            verify(initialY > PanelState.panelHeight);
+            print("intial", initialY, "panel", panelState.panelHeight);
+            verify(initialY > panelState.panelHeight);
 
             topLevelSurfaceList.inputMethodSurface.setInputBounds(Qt.rect(0, root.height / 2, root.width, root.height / 2));
             tryCompare(dashAppDelegate, "y", data.targetDisplacement);