QtMir

Merge lp:~unity-team/qtmir/miral-qt-integration into lp:qtmir

miral-qt-integration
Merge into trunk

Proposed by Daniel d'Andrada on 2016-12-01

Status:

Merged

Approved by:

Gerry Boland on 2016-12-07

Approved revision:

587

Merged at revision:

577

Proposed branch:

lp:~unity-team/qtmir/miral-qt-integration

Merge into:

lp:qtmir

Diff against target:

12804 lines (+5168/-3676)

139 files modified

CMakeLists.txt (+7/-4)
debian/changelog (+6/-0)
debian/control (+8/-4)
debian/gles-patches/convert-to-gles.patch (+1/-1)
demos/paths.h.in (+19/-1)
demos/qml-demo-shell/CMakeLists.txt (+1/-0)
demos/qml-demo-shell/WindowModelDebugView.qml (+72/-0)
demos/qml-demo-shell/main.cpp (+10/-6)
demos/qml-demo-shell/pointerposition.cpp (+56/-0)
demos/qml-demo-shell/pointerposition.h (+49/-0)
demos/qml-demo-shell/windowModel.qml (+136/-0)
src/common/appnotifier.h (+39/-0)
src/common/debughelpers.cpp (+50/-16)
src/common/debughelpers.h (+2/-0)
src/common/mirqtconversion.h (+118/-0)
src/common/windowcontrollerinterface.h (+58/-0)
src/common/windowmodelnotifier.h (+95/-0)
src/modules/Unity/Application/CMakeLists.txt (+4/-3)
src/modules/Unity/Application/application.cpp (+7/-6)
src/modules/Unity/Application/application.h (+1/-8)
src/modules/Unity/Application/application_manager.cpp (+40/-75)
src/modules/Unity/Application/application_manager.h (+7/-9)
src/modules/Unity/Application/dbusfocusinfo.cpp (+12/-18)
src/modules/Unity/Application/dbusfocusinfo.h (+0/-1)
src/modules/Unity/Application/mirfocuscontroller.cpp (+0/-69)
src/modules/Unity/Application/mirfocuscontroller.h (+0/-49)
src/modules/Unity/Application/mirsurface.cpp (+476/-248)
src/modules/Unity/Application/mirsurface.h (+61/-51)
src/modules/Unity/Application/mirsurfaceinterface.h (+6/-12)
src/modules/Unity/Application/mirsurfaceitem.cpp (+4/-33)
src/modules/Unity/Application/mirsurfaceitem.h (+1/-5)
src/modules/Unity/Application/mirsurfacelistmodel.cpp (+10/-4)
src/modules/Unity/Application/mirsurfacemanager.cpp (+0/-188)
src/modules/Unity/Application/mirsurfacemanager.h (+0/-99)
src/modules/Unity/Application/plugin.cpp (+6/-18)
src/modules/Unity/Application/session.cpp (+42/-28)
src/modules/Unity/Application/session.h (+11/-12)
src/modules/Unity/Application/session_interface.h (+8/-6)
src/modules/Unity/Application/sessionmanager.cpp (+24/-37)
src/modules/Unity/Application/sessionmanager.h (+11/-8)
src/modules/Unity/Application/surfacemanager.cpp (+174/-0)
src/modules/Unity/Application/surfacemanager.h (+73/-0)
src/modules/Unity/Application/windowmodel.cpp (+235/-0)
src/modules/Unity/Application/windowmodel.h (+83/-0)
src/modules/Unity/Screens/CMakeLists.txt (+1/-1)
src/modules/Unity/Screens/plugin.cpp (+1/-1)
src/modules/Unity/Screens/qquickscreenwindow.cpp (+6/-6)
src/modules/Unity/Screens/qquickscreenwindow.h (+6/-6)
src/modules/Unity/Screens/screens.cpp (+1/-1)
src/modules/Unity/Screens/screens.h (+2/-29)
src/platforms/mirserver/CMakeLists.txt (+39/-25)
src/platforms/mirserver/creationhints.cpp (+0/-67)
src/platforms/mirserver/creationhints.h (+0/-56)
src/platforms/mirserver/cursor.cpp (+1/-1)
src/platforms/mirserver/customscreenconfiguration.h (+4/-2)
src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp (+26/-1)
src/platforms/mirserver/mirdisplayconfigurationpolicy.h (+6/-14)
src/platforms/mirserver/miropenglcontext.cpp (+1/-0)
src/platforms/mirserver/mirserver.cpp (+0/-234)
src/platforms/mirserver/mirserver.h (+0/-71)
src/platforms/mirserver/mirserverhooks.cpp (+184/-0)
src/platforms/mirserver/mirserverhooks.h (+54/-0)
src/platforms/mirserver/mirserverintegration.cpp (+2/-2)
src/platforms/mirserver/mirserverstatuslistener.h (+1/-0)
src/platforms/mirserver/mirsingleton.cpp (+1/-0)
src/platforms/mirserver/mirwindowmanager.cpp (+0/-227)
src/platforms/mirserver/mirwindowmanager.h (+0/-49)
src/platforms/mirserver/nativeinterface.cpp (+1/-5)
src/platforms/mirserver/nativeinterface.h (+2/-2)
src/platforms/mirserver/offscreensurface.cpp (+0/-7)
src/platforms/mirserver/openglcontextfactory.cpp (+51/-0)
src/platforms/mirserver/openglcontextfactory.h (+47/-0)
src/platforms/mirserver/promptsession.h (+62/-0)
src/platforms/mirserver/promptsessionlistener.cpp (+2/-45)
src/platforms/mirserver/promptsessionlistener.h (+19/-21)
src/platforms/mirserver/promptsessionmanager.cpp (+47/-0)
src/platforms/mirserver/promptsessionmanager.h (+49/-0)
src/platforms/mirserver/qmirserver.cpp (+25/-52)
src/platforms/mirserver/qmirserver.h (+4/-7)
src/platforms/mirserver/qmirserver_p.cpp (+117/-25)
src/platforms/mirserver/qmirserver_p.h (+56/-10)
src/platforms/mirserver/qteventfeeder.cpp (+47/-23)
src/platforms/mirserver/qteventfeeder.h (+6/-12)
src/platforms/mirserver/screen.cpp (+26/-27)
src/platforms/mirserver/screen.h (+9/-14)
src/platforms/mirserver/screenscontroller.cpp (+1/-0)
src/platforms/mirserver/screenscontroller.h (+4/-1)
src/platforms/mirserver/screensmodel.cpp (+11/-5)
src/platforms/mirserver/screensmodel.h (+8/-4)
src/platforms/mirserver/screentypes.h (+60/-0)
src/platforms/mirserver/sessionauthorizer.cpp (+5/-10)
src/platforms/mirserver/sessionauthorizer.h (+7/-7)
src/platforms/mirserver/sessionlistener.cpp (+0/-96)
src/platforms/mirserver/sessionlistener.h (+0/-63)
src/platforms/mirserver/setqtcompositor.cpp (+55/-0)
src/platforms/mirserver/setqtcompositor.h (+47/-0)
src/platforms/mirserver/surfaceobserver.cpp (+36/-177)
src/platforms/mirserver/surfaceobserver.h (+9/-41)
src/platforms/mirserver/windowcontroller.cpp (+103/-0)
src/platforms/mirserver/windowcontroller.h (+54/-0)
src/platforms/mirserver/windowmanagementpolicy.cpp (+335/-0)
src/platforms/mirserver/windowmanagementpolicy.h (+96/-0)
tests/framework/CMakeLists.txt (+2/-0)
tests/framework/fake_displayconfigurationoutput.h (+1/-0)
tests/framework/fake_mirsurface.cpp (+31/-10)
tests/framework/fake_mirsurface.h (+18/-23)
tests/framework/fake_session.cpp (+7/-5)
tests/framework/fake_session.h (+5/-4)
tests/framework/fake_surface.h (+2/-0)
tests/framework/mock_mir_session.h (+9/-4)
tests/framework/mock_session.h (+5/-4)
tests/framework/mock_surface.h (+1/-0)
tests/framework/qtmir_test.cpp (+28/-4)
tests/framework/qtmir_test.h (+8/-5)
tests/framework/stub_scene_surface.h (+108/-0)
tests/framework/stub_windowcontroller.h (+44/-0)
tests/mirserver/CMakeLists.txt (+0/-1)
tests/mirserver/Screen/screen_test.cpp (+2/-2)
tests/mirserver/ScreensModel/screensmodel_test.cpp (+3/-1)
tests/mirserver/ScreensModel/stub_display.h (+10/-0)
tests/mirserver/ScreensModel/testable_screensmodel.h (+3/-2)
tests/mirserver/WindowManager/CMakeLists.txt (+0/-27)
tests/mirserver/WindowManager/stub_session.cpp (+0/-147)
tests/mirserver/WindowManager/stub_session.h (+0/-64)
tests/mirserver/WindowManager/stub_surface.cpp (+0/-212)
tests/mirserver/WindowManager/stub_surface.h (+0/-71)
tests/mirserver/WindowManager/window_manager.cpp (+0/-332)
tests/modules/Application/CMakeLists.txt (+1/-0)
tests/modules/Application/application_test.cpp (+10/-10)
tests/modules/ApplicationManager/CMakeLists.txt (+1/-0)
tests/modules/ApplicationManager/application_manager_test.cpp (+202/-192)
tests/modules/CMakeLists.txt (+1/-1)
tests/modules/SessionManager/CMakeLists.txt (+1/-0)
tests/modules/SessionManager/session_manager_test.cpp (+24/-16)
tests/modules/SessionManager/session_test.cpp (+14/-13)
tests/modules/WindowManager/CMakeLists.txt (+12/-6)
tests/modules/WindowManager/mirsurface_test.cpp (+67/-52)
tests/modules/WindowManager/mirsurfaceitem_test.cpp (+2/-2)
tests/modules/WindowManager/windowmodel_test.cpp (+786/-0)

To merge this branch:

bzr merge lp:~unity-team/qtmir/miral-qt-integration

Undecided

Won't Fix

Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot (community)	continuous-integration	2016-12-01	Approve on 2016-12-08
Gerry Boland (community)	code	2016-12-01	Approve on 2016-12-07
Review via email: mp+312244@code.launchpad.net

This proposal supersedes a proposal from 2016-11-03.

Commit message

Depend on MirAL

Import code from lp:miral/miral-qt (revision 435) where we had a fork of qtmir and were rewriting it to use MirAL's APIs

Description of the change

Prereq-archive: ppa:ci-train-ppa-service/2160

Needed:
https://code.launchpad.net/~unity-team/unity-api/miral/+merge/309938
https://code.launchpad.net/~dandrader/unity8/miral/+merge/312194

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-03: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/393/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-03: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/394/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-04: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/395/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-04: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/396/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-04: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/397/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-07: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/398/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-07: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/399/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-09: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/401/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-09: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/402/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-16: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/404/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-17: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/405/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-24: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/413/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-25: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/414/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-01:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/419/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-01: Posted in a previous version of this proposal

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/418/rebuild

review: Needs Fixing (continuous-integration)

lp:~unity-team/qtmir/miral-qt-integration updated on 2016-12-01

585. By Daniel d'Andrada on 2016-12-01: Fix order of entries in debian/changelog

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-01:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/420/rebuild

review: Needs Fixing (continuous-integration)

Gerry Boland (gerboland) wrote on 2016-12-05:

+++ src/common/mirqtconversion.h
missing licence header

review: Needs Fixing

lp:~unity-team/qtmir/miral-qt-integration updated on 2016-12-05

586. By Daniel d'Andrada on 2016-12-05: Add missing license header

Daniel d'Andrada (dandrader) wrote on 2016-12-05:

On 05/12/2016 12:59, Gerry Boland wrote:
> Review: Needs Fixing
>
> +++ src/common/mirqtconversion.h
> missing licence header

Fixed

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-05:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/421/rebuild

review: Needs Fixing (continuous-integration)

lp:~unity-team/qtmir/miral-qt-integration updated on 2016-12-07

587. By Daniel d'Andrada on 2016-12-07: findApplicationWithSurface is const

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-07:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/423/rebuild

review: Needs Fixing (continuous-integration)

Gerry Boland (gerboland) on 2016-12-07:

review: Approve (code)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-12-08:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/426/rebuild

review: Approve (continuous-integration)

lp:~unity-team/qtmir/miral-qt-integration updated on 2016-12-16

588. By Daniel d'Andrada on 2016-12-13: Mir 0.25 compat (merging upcoming trunk)
589. By Daniel d'Andrada on 2016-12-13: Bump dependency version of other mir packages
590. By Daniel d'Andrada on 2016-12-16: Fix bad merge

Preview Diff

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

The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mir development team

Unity Team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-12-03 12:37:37 +0000
 +++ CMakeLists.txt	2016-12-16 08:22:54 +0000
@@ -3,7 +3,7 @@
  project(qtmir)
  set(QTMIR_VERSION_MAJOR 0)
--set(QTMIR_VERSION_MINOR 1)
++set(QTMIR_VERSION_MINOR 2)
  set(QTMIR_VERSION_PATCH 0)
  if(${PROJECT_BINARY_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
@@ -30,6 +30,10 @@
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wall -fno-strict-aliasing -Werror -Wextra")
  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
++if ("${CMAKE_CXX_COMPILER}" MATCHES "clang")
++    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage -Wno-mismatched-tags -Wno-inconsistent-missing-override -Wno-implicit-exception-spec-mismatch -Wno-unknown-pragmas")
++endif()
++
  include(EnableCoverageReport)
  #####################################################################
@@ -70,6 +74,7 @@
  pkg_check_modules(MIRSERVER mirserver>=0.25 REQUIRED)
  pkg_check_modules(MIRCLIENT mirclient>=0.25 REQUIRED)
  pkg_check_modules(MIRRENDERERGLDEV mir-renderer-gl-dev>=0.24 REQUIRED)
++pkg_check_modules(MIRAL miral>=0.4 REQUIRED)
  pkg_check_modules(XKBCOMMON xkbcommon REQUIRED)
  pkg_check_modules(GLIB glib-2.0 REQUIRED)
@@ -83,15 +88,13 @@
  pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
  pkg_check_modules(QTDBUSTEST libqtdbustest-1 REQUIRED)
  pkg_check_modules(QTDBUSMOCK libqtdbusmock-1 REQUIRED)
--pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=22)
++pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=23)
  pkg_check_modules(CGMANAGER libcgmanager REQUIRED)
  pkg_check_modules(CONTENT_HUB libcontent-hub>=0.2 REQUIRED)
  include_directories(SYSTEM ${APPLICATION_API_INCLUDE_DIRS})
--add_definitions(-DMIR_REQUIRE_DEPRECATED_EVENT_OPT_IN=1)
--
  # Use the fast string builder
  add_definitions(-DQT_USE_QSTRINGBUILDER)
 === modified file 'debian/changelog'
 --- debian/changelog	2016-12-03 12:38:04 +0000
 +++ debian/changelog	2016-12-16 08:22:54 +0000
@@ -1,3 +1,9 @@
++qtmir (0.5.1) UNRELEASED; urgency=medium
++
++  * First release using MirAL
++
++ -- Gerry Boland <gerry.boland@canonical.com>  Fri, 14 Oct 2016 16:51:26 +0100
++
  qtmir (0.5.0+17.04.20161203-0ubuntu1) zesty; urgency=medium
    * Mir 0.25 compat
 === modified file 'debian/control'
 --- debian/control	2016-11-16 17:49:19 +0000
 +++ debian/control	2016-12-16 08:22:54 +0000
@@ -13,6 +13,7 @@
                 libglib2.0-dev,
                 libgsettings-qt-dev,
                 liblttng-ust-dev,
++               libmiral-dev (>= 0.4),
                 libmirclient-dev (>= 0.25.0),
                 libmircommon-dev (>= 0.25.0),
                 libmirserver-dev (>= 0.25.0),
@@ -24,12 +25,12 @@
                 libubuntu-app-launch2-dev (>= 0.9),
                 libubuntu-application-api-dev (>= 2.1.0),
                 libudev-dev,
--               libunity-api-dev (>= 7.119),
++               libunity-api-dev (>= 8.0),
                 liburl-dispatcher1-dev,
                 libxkbcommon-dev,
                 libxrender-dev,
--               mir-renderer-gl-dev (>= 0.24.0),
--               mirtest-dev (>= 0.24.0),
++               mir-renderer-gl-dev (>= 0.25.0),
++               mirtest-dev (>= 0.25.0),
                 pkg-config,
  # lttng-gen-ts needs python3, but doesn't depend on it itself: bug 1359147
                 python3:any,
@@ -41,6 +42,9 @@
                 quilt,
  # libmirserver-dev should have brought this dep. Bug lp:1617435
                 uuid-dev,
++# mirtest pkgconfig requires these, but doesn't have a deb dependency. Bug lp:1633537
++               libboost-filesystem-dev,
++               libboost-system-dev,
  Standards-Version: 3.9.5
  Homepage: https://launchpad.net/qtmir
  # if you don't have have commit access to this branch but would like to upload
@@ -98,7 +102,7 @@
  Conflicts: libqtmir,
             libunity-mir1,
  Provides: unity-application-impl,
--          unity-application-impl-22,
++          unity-application-impl-23,
  Description: Qt plugin for Unity specific Mir APIs
   QtMir provides Qt/QML bindings for Mir features that are exposed through the
   qtmir-desktop or qtmir-android QPA plugin such as Application management
 === modified file 'debian/gles-patches/convert-to-gles.patch'
 --- debian/gles-patches/convert-to-gles.patch	2016-11-23 19:46:24 +0000
 +++ debian/gles-patches/convert-to-gles.patch	2016-12-16 08:22:54 +0000
@@ -84,7 +84,7 @@
  -Conflicts: libqtmir,
  -           libunity-mir1,
  -Provides: unity-application-impl,
---          unity-application-impl-22,
++-          unity-application-impl-23,
  -Description: Qt plugin for Unity specific Mir APIs
  - QtMir provides Qt/QML bindings for Mir features that are exposed through the
  - qtmir-desktop or qtmir-android QPA plugin such as Application management
 === modified file 'demos/paths.h.in'
 --- demos/paths.h.in	2015-09-01 16:16:47 +0000
 +++ demos/paths.h.in	2016-12-16 08:22:54 +0000
@@ -37,4 +37,22 @@
          return QString("@CMAKE_SOURCE_DIR@/demos/");
+     }
+ }
--#endif
 \ No newline at end of file
++
++inline QString qmlPluginDirectory() {
++    if (isRunningInstalled()) {
++        return QString("@QML_MODULE_INSTALL_DIR@/");
++    } else {
++        return QString("@CMAKE_BINARY_DIR@/src/modules/");
++    }
++}
++
++inline QString qpaPluginDirectory() {
++    if (isRunningInstalled()) {
++        return QString("@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@/qt5/plugins/platforms/");
++    } else {
++        return QString("@CMAKE_BINARY_DIR@/src/platforms/mirserver/");
++    }
++}
++
++#endif
++
 === modified file 'demos/qml-demo-shell/CMakeLists.txt'
 --- demos/qml-demo-shell/CMakeLists.txt	2016-06-06 18:12:07 +0000
 +++ demos/qml-demo-shell/CMakeLists.txt	2016-12-16 08:22:54 +0000
@@ -8,6 +8,7 @@
+ )
  add_executable(${DEMO_SHELL}
++    pointerposition.cpp
      main.cpp
+ )
 === added file 'demos/qml-demo-shell/WindowModelDebugView.qml'
 --- demos/qml-demo-shell/WindowModelDebugView.qml	1970-01-01 00:00:00 +0000
 +++ demos/qml-demo-shell/WindowModelDebugView.qml	2016-12-16 08:22:54 +0000
@@ -0,0 +1,72 @@
++import QtQuick 2.0
++import Unity.Application 0.1
++
++Column {
++    id: root
++    width: childrenRect.width
++    height: childrenRect.height
++    focus: false
++
++    property alias model: repeater.model
++
++    function stateString(state) {
++        switch(state) {
++        case Mir.HiddenState:         return "Hidden"
++        case Mir.RestoredState:       return "Restored"
++        case Mir.MinimizedState:      return "Minimized"
++        case Mir.MaximizedState:      return "Maximized"
++        case Mir.VertMaximizedState:  return "VertMax"
++        case Mir.FullscreenState:     return "Fullscreen"
++        case Mir.HorizMaximizedState: return "HorizMax"
++        case Mir.UnknownState:        return "Unknown"
++        }
++        return "Invalid"
++    }
++    function typeString(type) {
++        switch(type) {
++        case Mir.UnknownType:   return "Unknown"
++        case Mir.NormalType:        return "Normal"
++        case Mir.UtilityType:       return "Utility"
++        case Mir.DialogType:        return "Dialog"
++        case Mir.GlossType:         return "Gloss"
++        case Mir.FreeStyleType:     return "FreeStyle"
++        case Mir.MenuType:          return "Menu"
++        case Mir.InputMethodType:   return "InputMethod"
++        case Mir.SatelliteType:     return "Satellite"
++        case Mir.TipType:           return "Tip"
++        }
++        return "Invalid"
++    }
++
++    function geometryString(surface) {
++        return surface.position.x + "," + surface.position.y + " " + surface.size.width + "x" + surface.size.height
++    }
++
++
++    Text {
++        text: "Index\t\Name\tVisible\tState\tType\tGeometry"
++        height: (visible) ? implicitHeight : 0
++        visible: repeater.count > 0
++        color: "white"
++
++        Rectangle {
++            anchors.fill: parent
++            color: "blue"
++            z: -1
++        }
++    }
++    Repeater {
++        id: repeater
++        delegate: Text {
++            text: index + "\t" + surface.name + "\t" + surface.visible + "\t"
++                  + stateString(surface.state) + "\t" +  typeString(surface.type) + "\t" + geometryString(surface)
++            font.bold: surface.focused
++
++            Rectangle {
++                anchors.fill: parent
++                color: (index % 2) ? "white" : "lightblue"
++                z: -1
++            }
++        }
++    }
++}
 === modified file 'demos/qml-demo-shell/main.cpp'
 --- demos/qml-demo-shell/main.cpp	2015-09-17 11:20:00 +0000
 +++ demos/qml-demo-shell/main.cpp	2016-12-16 08:22:54 +0000
@@ -15,34 +15,38 @@
   */
  // Qt
--#include <QCommandLineParser>
  #include <QtQuick/QQuickView>
  #include <QtGui/QGuiApplication>
  #include <QtQml/QQmlEngine>
  #include <QtQml/QQmlContext>
--#include <QLibrary>
  #include <QDebug>
--#include <csignal>
  #include <libintl.h>
  #include "../paths.h"
--#include <private/qobject_p.h>
++#include "pointerposition.h"
  // REMOVEME - Should be able to use qmlscene, but in order to use the mir benchmarking we need
  // to parse command line switches. Wait until MIR_SOCKET supported by the benchmark framework.
  int main(int argc, const char *argv[])
+ {
++    setenv("QT_QPA_PLATFORM_PLUGIN_PATH", qPrintable(::qpaPluginDirectory()), 1 /* overwrite */);
++    setenv("QT_QPA_PLATFORM", "mirserver", 1 /* overwrite */);
++
      QGuiApplication::setApplicationName("qml-demo-shell");
      QGuiApplication *application;
      application = new QGuiApplication(argc, (char**)argv);
      QQuickView* view = new QQuickView();
++    view->engine()->addImportPath(::qmlPluginDirectory());
      view->setResizeMode(QQuickView::SizeRootObjectToView);
--    view->setColor("black");
++    view->setColor("lightgray");
      view->setTitle("Demo Shell");
--    QUrl source(::qmlDirectory() + "qtmir-demo-shell/qml-demo-shell.qml");
++    qmlRegisterSingletonType<PointerPosition>("Mir.Pointer", 0, 1, "PointerPosition",
++        [](QQmlEngine*, QJSEngine*) -> QObject* { return PointerPosition::instance(); });
++
++    QUrl source(::qmlDirectory() + "qml-demo-shell/windowModel.qml");
      view->setSource(source);
      QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
 === added file 'demos/qml-demo-shell/pointerposition.cpp'
 --- demos/qml-demo-shell/pointerposition.cpp	1970-01-01 00:00:00 +0000
 +++ demos/qml-demo-shell/pointerposition.cpp	2016-12-16 08:22:54 +0000
@@ -0,0 +1,56 @@
++/*
++ * 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/>.
++ */
++
++#include "pointerposition.h"
++
++#include <QGuiApplication>
++#include <QMouseEvent>
++
++PointerPosition *PointerPosition::instance()
++{
++    static PointerPosition *pointerPosition = nullptr;
++    if (!pointerPosition) {
++        pointerPosition = new PointerPosition();
++    }
++    return pointerPosition;
++}
++
++bool PointerPosition::eventFilter(QObject */*object*/, QEvent *event)
++{
++    if (event->type() == QEvent::MouseMove) {
++        auto mouseEvent = static_cast<QMouseEvent*>(event);
++        if (m_x != mouseEvent->globalX()) {
++            m_x = mouseEvent->globalX();
++            Q_EMIT xChanged();
++        }
++        if (m_y != mouseEvent->globalY()) {
++            m_y = mouseEvent->globalY();
++            Q_EMIT yChanged();
++        }
++    }
++    return false;
++}
++
++PointerPosition::PointerPosition()
++    : QObject()
++{
++    qGuiApp->installEventFilter(this);
++}
++
++PointerPosition::~PointerPosition()
++{
++    qGuiApp->removeEventFilter(this);
++}
 === added file 'demos/qml-demo-shell/pointerposition.h'
 --- demos/qml-demo-shell/pointerposition.h	1970-01-01 00:00:00 +0000
 +++ demos/qml-demo-shell/pointerposition.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,49 @@
++/*
++ * 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/>.
++ */
++
++#ifndef POINTERPOSITION_H
++#define POINTERPOSITION_H
++
++#include <QObject>
++
++class PointerPosition : public QObject
++{
++    Q_OBJECT
++    Q_PROPERTY(int x READ x NOTIFY xChanged)
++    Q_PROPERTY(int y READ y NOTIFY yChanged)
++
++public:
++    static PointerPosition *instance();
++
++    int x() const { return m_x; }
++    int y() const { return m_y; }
++
++Q_SIGNALS:
++    void xChanged();
++    void yChanged();
++
++protected:
++    bool eventFilter(QObject *object, QEvent *event);
++
++private:
++    Q_DISABLE_COPY(PointerPosition)
++    PointerPosition();
++    ~PointerPosition();
++
++    int m_x{0}, m_y{0};
++};
++
++#endif // POINTERPOSITION_H
 === added file 'demos/qml-demo-shell/windowModel.qml'
 --- demos/qml-demo-shell/windowModel.qml	1970-01-01 00:00:00 +0000
 +++ demos/qml-demo-shell/windowModel.qml	2016-12-16 08:22:54 +0000
@@ -0,0 +1,136 @@
++import QtQuick 2.4
++import Unity.Application 0.1
++import Mir.Pointer 0.1
++
++FocusScope {
++    id: root
++    focus: true
++
++    WindowModel {
++        id: windowModel;
++    }
++
++    Item {
++        id: windowViewContainer
++        anchors.fill: parent
++
++        Repeater {
++            model: windowModel
++
++            delegate: MirSurfaceItem {
++                id: surfaceItem
++                surface: model.surface
++                consumesInput: true // QUESTION: why is this non-default?
++                x: surface.position.x
++                y: surface.position.y
++                width: surface.size.width
++                height: surface.size.height
++                focus: surface.focused
++                visible: surface.visible
++
++                Rectangle {
++                    anchors { top: parent.bottom; right: parent.right }
++                    width: childrenRect.width
++                    height: childrenRect.height
++                    color: surface.focused ? "red" : "lightsteelblue"
++                    opacity: 0.8
++                    Text {
++                        text: surface.position.x + "," + surface.position.y + " " + surface.size.width + "x" + surface.size.height
++                        font.pixelSize: 10
++                    }
++                }
++
++                Rectangle { anchors.fill: parent; z: -1; color: "black"; opacity: 0.3 }
++            }
++        }
++    }
++
++    Button {
++        anchors { right: parent.right; top: parent.top }
++        height: 30
++        width: 80
++        text: "Quit"
++        onClicked: Qt.quit()
++    }
++
++    WindowModelDebugView {
++        anchors { right: parent.right; bottom: parent.bottom }
++        model: windowModel
++    }
++
++    Text {
++        anchors { left: parent.left; bottom: parent.bottom }
++        text: "Move window: Ctrl+click\n
++Resize window: Ctrl+Right click"
++    }
++
++    Rectangle {
++        id: mousePointer
++        color: "black"
++        width: 6
++        height: 10
++        x: PointerPosition.x
++        y: PointerPosition.y
++    }
++
++    MouseArea {
++        anchors.fill: parent
++        acceptedButtons: Qt.LeftButton | Qt.RightButton
++        hoverEnabled: false
++        property variant window: null
++        property int initialWindowXPosition
++        property int initialWindowYPosition
++        property int initialWindowWidth
++        property int initialWindowHeight
++        property int initialMouseXPosition
++        property int initialMouseYPosition
++        property var action
++
++        function moveWindowBy(window, delta) {
++            window.surface.requestedPosition = Qt.point(initialWindowXPosition + delta.x,
++                                                        initialWindowYPosition + delta.y);
++        }
++        function resizeWindowBy(window, delta) {
++            window.surface.resize(Qt.size(initialWindowWidth + delta.x,
++                                          initialWindowHeight + delta.y))
++        }
++
++        onPressed: {
++            if (mouse.modifiers & Qt.ControlModifier) {
++                window = windowViewContainer.childAt(mouse.x, mouse.y)
++                if (!window) return;
++
++                if (mouse.button == Qt.LeftButton) {
++                    initialWindowXPosition = window.surface.position.x
++                    initialWindowYPosition = window.surface.position.y
++                    action = moveWindowBy
++                } else if (mouse.button == Qt.RightButton) {
++                    initialWindowHeight = window.surface.size.height
++                    initialWindowWidth = window.surface.size.width
++                    action = resizeWindowBy
++                }
++                initialMouseXPosition = mouse.x
++                initialMouseYPosition = mouse.y
++            } else {
++                mouse.accepted = false
++            }
++        }
++
++        onPositionChanged: {
++            if (!window) {
++                mouse.accepted = false
++                return
++            }
++            action(window, Qt.point(mouse.x - initialMouseXPosition, mouse.y - initialMouseYPosition))
++        }
++
++        onReleased: {
++            if (!window) {
++                mouse.accepted = false
++                return
++            }
++            action(window, Qt.point(mouse.x - initialMouseXPosition, mouse.y - initialMouseYPosition))
++            window = null;
++        }
++    }
++}
 === added file 'src/common/appnotifier.h'
 --- src/common/appnotifier.h	1970-01-01 00:00:00 +0000
 +++ src/common/appnotifier.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,39 @@
++/*
++ * 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 APPNOTIFIER_H
++#define APPNOTIFIER_H
++
++#include <QObject>
++#include <miral/application_info.h>
++
++namespace qtmir {
++
++class AppNotifier : public QObject
++{
++    Q_OBJECT
++
++Q_SIGNALS:
++    void appAdded(const miral::ApplicationInfo &app);
++    void appRemoved(const miral::ApplicationInfo &app);
++    void appCreatedWindow(const miral::ApplicationInfo &app);
++};
++
++} // namespace qtmir
++
++Q_DECLARE_METATYPE(miral::ApplicationInfo)
++
++#endif // APPNOTIFIER_H
 === modified file 'src/common/debughelpers.cpp'
 --- src/common/debughelpers.cpp	2016-06-06 19:25:20 +0000
 +++ src/common/debughelpers.cpp	2016-12-16 08:22:54 +0000
@@ -21,6 +21,7 @@
  // Unity API
  #include <unity/shell/application/ApplicationInfoInterface.h>
++#include <unity/shell/application/Mir.h>
  const char *touchPointStateToString(Qt::TouchPointState state)
+ {
@@ -114,23 +115,18 @@
  const char *mirSurfaceTypeToStr(int value)
+ {
      switch (value) {
--    case mir_surface_type_normal:
--        return "normal";
--    case mir_surface_type_utility:
--        return "utility";
--    case mir_surface_type_dialog:
--        return "dialog";
--    case mir_surface_type_overlay:
--        return "overlay";
--    case mir_surface_type_freestyle:
--        return "freestyle";
--    case mir_surface_type_popover:
--        return "popover";
--    case mir_surface_type_inputmethod:
--        return "inputmethod";
--    default:
--        return "???";
++    case mir_surface_type_normal:       return "normal";        /**< AKA "regular"                   */
++    case mir_surface_type_utility:      return "utility";       /**< AKA "floating regular"          */
++    case mir_surface_type_dialog:       return "dialog";
++    case mir_surface_type_gloss:        return "gloss";
++    case mir_surface_type_freestyle:    return "freestyle";
++    case mir_surface_type_menu:         return "menu";
++    case mir_surface_type_inputmethod:  return "input Method";  /**< AKA "OSK" or handwriting etc.   */
++    case mir_surface_type_satellite:    return "satellite";     /**< AKA "toolbox"/"toolbar"         */
++    case mir_surface_type_tip:          return "tip";           /**< AKA "tooltip"                   */
++    case mir_surface_types:             Q_UNREACHABLE();
+     }
++    Q_UNREACHABLE();
+ }
  const char *mirSurfaceStateToStr(int value)
@@ -148,6 +144,8 @@
          return "vertmaximized";
      case mir_surface_state_fullscreen:
          return "fullscreen";
++    case mir_surface_state_hidden:
++        return "hidden";
      default:
          return "???";
+     }
@@ -349,3 +347,39 @@
          return "???";
+     }
+ }
++
++const char *unityapiMirStateToStr(int state)
++{
++    switch (state) {
++    case Mir::UnknownState:
++        return "unknown";
++    case Mir::RestoredState:
++        return "restored";
++    case Mir::MinimizedState:
++        return "minimized";
++    case Mir::MaximizedState:
++        return "maximized";
++    case Mir::VertMaximizedState:
++        return "vertMaximized";
++    case Mir::FullscreenState:
++        return "fullscreen";
++    case Mir::HorizMaximizedState:
++        return "horizMaximized";
++    case Mir::MaximizedLeftState:
++        return "maximizedLeft";
++    case Mir::MaximizedRightState:
++        return "maximizedRight";
++    case Mir::MaximizedTopLeftState:
++        return "maximizedTopLeft";
++    case Mir::MaximizedTopRightState:
++        return "maximizedTopRight";
++    case Mir::MaximizedBottomLeftState:
++        return "maximizedBottomLeft";
++    case Mir::MaximizedBottomRightState:
++        return "maximizedBottomRight";
++    case Mir::HiddenState:
++        return "hidden";
++    default:
++        return "???";
++    }
++}
 === modified file 'src/common/debughelpers.h'
 --- src/common/debughelpers.h	2015-11-10 11:07:23 +0000
 +++ src/common/debughelpers.h	2016-12-16 08:22:54 +0000
@@ -43,4 +43,6 @@
  const char *qtCursorShapeToStr(Qt::CursorShape shape);
++const char *unityapiMirStateToStr(int state);
++
  #endif // UBUNTUGESTURES_DEBUG_HELPER_H
 === added file 'src/common/mirqtconversion.h'
 --- src/common/mirqtconversion.h	1970-01-01 00:00:00 +0000
 +++ src/common/mirqtconversion.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,118 @@
++/*
++ * 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 MIRQTCONVERSION_H
++#define MIRQTCONVERSION_H
++
++#include <QSize>
++#include <QPoint>
++#include <QRect>
++
++#include <mir/geometry/size.h>
++#include <mir/geometry/point.h>
++#include <mir/geometry/rectangle.h>
++
++#include <mir_toolkit/common.h>
++
++#include <unity/shell/application/Mir.h>
++
++namespace qtmir {
++
++/*
++ * Some handy conversions from Mir types to Qt types and back
++ */
++
++inline QSize toQSize(const mir::geometry::Size size)
++{
++    return QSize(size.width.as_int(), size.height.as_int());
++}
++
++inline mir::geometry::Size toMirSize(const QSize size)
++{
++    namespace mg = mir::geometry;
++    return mg::Size{ mg::Width{ size.width()}, mg::Height{ size.height()} };
++}
++
++inline QPoint toQPoint(const mir::geometry::Point point)
++{
++    return QPoint(point.x.as_int(), point.y.as_int());
++}
++
++inline mir::geometry::Point toMirPoint(const QPoint point)
++{
++    namespace mg = mir::geometry;
++    return mg::Point{ mg::X{ point.x()}, mg::Y{ point.y()} };
++}
++
++inline QRect toQRect(const mir::geometry::Rectangle rect)
++{
++    return QRect(rect.top_left.x.as_int(), rect.top_left.y.as_int(),
++                 rect.size.width.as_int(), rect.size.height.as_int());
++}
++
++inline mir::geometry::Rectangle toMirRectangle(const QRect rect)
++{
++    namespace mg = mir::geometry;
++    return mg::Rectangle{
++        mg::Point{ mg::X{ rect.x()}, mg::Y{ rect.y()} },
++        mg::Size{ mg::Width{ rect.width()}, mg::Height{ rect.height()} }
++    };
++}
++
++inline Mir::State toQtState(MirSurfaceState state)
++{
++    switch (state) {
++    case mir_surface_state_unknown:         return Mir::UnknownState;
++    case mir_surface_state_restored:        return Mir::RestoredState;
++    case mir_surface_state_minimized:       return Mir::MinimizedState;
++    case mir_surface_state_maximized:       return Mir::MaximizedState;
++    case mir_surface_state_vertmaximized:   return Mir::VertMaximizedState;
++    case mir_surface_state_fullscreen:      return Mir::FullscreenState;
++    case mir_surface_state_horizmaximized:  return Mir::HorizMaximizedState;
++    case mir_surface_state_hidden:          return Mir::HiddenState;
++    case mir_surface_states:                Q_UNREACHABLE();
++    }
++    Q_UNREACHABLE();
++}
++
++inline MirSurfaceState toMirState(Mir::State state)
++{
++    switch (state) {
++    case Mir::UnknownState:         return mir_surface_state_unknown;
++    case Mir::RestoredState:        return mir_surface_state_restored;
++    case Mir::MinimizedState:       return mir_surface_state_minimized;
++    case Mir::MaximizedState:       return mir_surface_state_maximized;
++    case Mir::VertMaximizedState:   return mir_surface_state_vertmaximized;
++    case Mir::FullscreenState:      return mir_surface_state_fullscreen;
++    case Mir::HorizMaximizedState:  return mir_surface_state_horizmaximized;
++
++    // FIXME: Map to the corresponding MirSurfaceState enum value once available
++    case Mir::MaximizedLeftState:
++    case Mir::MaximizedRightState:
++    case Mir::MaximizedTopLeftState:
++    case Mir::MaximizedTopRightState:
++    case Mir::MaximizedBottomLeftState:
++    case Mir::MaximizedBottomRightState:
++        return mir_surface_state_restored;
++
++    case Mir::HiddenState:          return mir_surface_state_hidden;
++    default: Q_UNREACHABLE();
++    }
++}
++
++} // namespace qtmir
++
++#endif // MIRQTCONVERSION_H
 === added file 'src/common/windowcontrollerinterface.h'
 --- src/common/windowcontrollerinterface.h	1970-01-01 00:00:00 +0000
 +++ src/common/windowcontrollerinterface.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,58 @@
++/*
++ * 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 WINDOWCONTROLLERINTERFACE_H
++#define WINDOWCONTROLLERINTERFACE_H
++
++#include <miral/window.h>
++
++#include <mir_toolkit/event.h>
++
++#include <QPoint>
++#include <QSize>
++
++// Unity API
++#include <unity/shell/application/Mir.h>
++
++namespace qtmir {
++
++class MirSurface;
++
++class WindowControllerInterface {
++public:
++    WindowControllerInterface() = default;
++    virtual ~WindowControllerInterface() = default;
++
++    // activate() asks Mir to bring particular window to the front and recommend to shell that it be focused
++    virtual void activate (const miral::Window &window) = 0;
++    virtual void raise(const miral::Window &window) = 0;
++
++    virtual void resize(const miral::Window &window, const QSize &size) = 0;
++    virtual void move  (const miral::Window &window, const QPoint &topLeft) = 0;
++
++    virtual void requestClose(const miral::Window &window) = 0;
++    virtual void forceClose(const miral::Window &window) = 0;
++
++    virtual void requestState(const miral::Window &window, const Mir::State state) = 0;
++
++    virtual void deliverKeyboardEvent(const miral::Window &window, const MirKeyboardEvent *event) = 0;
++    virtual void deliverTouchEvent   (const miral::Window &window, const MirTouchEvent *event) = 0;
++    virtual void deliverPointerEvent (const miral::Window &window, const MirPointerEvent *event) = 0;
++};
++
++} // namespace qtmir
++
++#endif // WINDOWCONTROLLERINTERFACE_H
 === added file 'src/common/windowmodelnotifier.h'
 --- src/common/windowmodelnotifier.h	1970-01-01 00:00:00 +0000
 +++ src/common/windowmodelnotifier.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,95 @@
++/*
++ * 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 WINDOWMODELNOTIFIER_H
++#define WINDOWMODELNOTIFIER_H
++
++#include <QObject>
++#include <QPoint>
++#include <QSize>
++
++#include <miral/window_info.h>
++
++// Unity API
++#include <unity/shell/application/Mir.h>
++
++namespace qtmir {
++
++class NewWindow {
++public:
++    NewWindow() = default;
++    NewWindow(const miral::WindowInfo &windowInfo)
++      : windowInfo(windowInfo)
++      , surface(windowInfo.window())
++    {}
++
++    miral::WindowInfo windowInfo;
++
++    // hold copy of Surface shared pointer, as miral::Window has just a weak pointer to the Surface
++    // but MirSurface needs to share ownership of the Surface with Mir
++    std::shared_ptr<mir::scene::Surface> surface;
++};
++
++struct ExtraWindowInfo {
++    QString persistentId;
++
++    // FIXME Use MirSurfaceState when possible.
++    Mir::State previousState{Mir::UnknownState};
++
++    // FIXME: Remove when possible. This exists just because MirSurfaceState has no equivalent
++    //        for the following states:
++    // Mir::MaximizedLeftState:
++    // Mir::MaximizedRightState:
++    // Mir::MaximizedTopLeftState:
++    // Mir::MaximizedTopRightState:
++    // Mir::MaximizedBottomLeftState:
++    // Mir::MaximizedBottomRightState:
++    Mir::State state{Mir::UnknownState};
++};
++
++std::shared_ptr<ExtraWindowInfo> getExtraInfo(const miral::WindowInfo &windowInfo);
++
++class WindowModelNotifier : public QObject
++{
++    Q_OBJECT
++public:
++    WindowModelNotifier() = default;
++
++Q_SIGNALS: // **Must used Queued Connection or else events will be out of order**
++    void windowAdded(const qtmir::NewWindow &window);
++    void windowRemoved(const miral::WindowInfo &window);
++    void windowReady(const miral::WindowInfo &window);
++    void windowMoved(const miral::WindowInfo &window, const QPoint topLeft);
++    void windowResized(const miral::WindowInfo &window, const QSize size);
++    void windowStateChanged(const miral::WindowInfo &window, Mir::State state);
++    void windowFocusChanged(const miral::WindowInfo &window, bool focused);
++    void windowsRaised(const std::vector<miral::Window> &windows); // results in deep copy when passed over Queued connection:(
++    void windowRequestedRaise(const miral::WindowInfo &window);
++    void modificationsStarted();
++    void modificationsEnded();
++
++private:
++    Q_DISABLE_COPY(WindowModelNotifier)
++};
++
++} // namespace qtmir
++
++Q_DECLARE_METATYPE(qtmir::NewWindow)
++Q_DECLARE_METATYPE(miral::WindowInfo)
++Q_DECLARE_METATYPE(std::vector<miral::Window>)
++Q_DECLARE_METATYPE(MirSurfaceState)
++
++#endif // WINDOWMODELNOTIFIER_H
 === modified file 'src/modules/Unity/Application/CMakeLists.txt'
 --- src/modules/Unity/Application/CMakeLists.txt	2016-07-30 21:19:45 +0000
 +++ src/modules/Unity/Application/CMakeLists.txt	2016-12-16 08:22:54 +0000
@@ -8,6 +8,7 @@
      ${GLIB_INCLUDE_DIRS}
      ${GIO_INCLUDE_DIRS}
      ${GIO_UNIX_INCLUDE_DIRS}
++    ${MIRAL_INCLUDE_DIRS}
      ${MIRSERVER_INCLUDE_DIRS}
      ${MIRRENDERERGLDEV_INCLUDE_DIRS}
      ${PROCESS_CPP_INCLUDE_DIRS}
@@ -35,8 +36,6 @@
      ../../../common/debughelpers.cpp
      dbusfocusinfo.cpp
      plugin.cpp
--    mirsurfacemanager.cpp
--    mirfocuscontroller.cpp
      mirsurface.cpp
      mirsurfaceinterface.h
      mirsurfaceitem.cpp
@@ -46,20 +45,22 @@
      session.cpp
      sessionmanager.cpp
      sharedwakelock.cpp
++    surfacemanager.cpp
      upstart/applicationinfo.cpp
      upstart/taskcontroller.cpp
      timer.cpp
      timesource.cpp
      tracepoints.c
      settings.cpp
++    windowmodel.cpp
  # We need to run moc on these headers
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
--    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirFocusControllerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceItemInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/SurfaceManagerInterface.h
  # Feed the automoc monster
      session_interface.h
      applicationinfo.h
 === modified file 'src/modules/Unity/Application/application.cpp'
 --- src/modules/Unity/Application/application.cpp	2016-08-10 06:52:18 +0000
 +++ src/modules/Unity/Application/application.cpp	2016-12-16 08:22:54 +0000
@@ -409,11 +409,7 @@
  bool Application::focused() const
+ {
--    bool someSurfaceHasFocus = false; // to be proven wrong
--    for (int i = 0; i < m_proxySurfaceList->rowCount() && !someSurfaceHasFocus; ++i) {
--        someSurfaceHasFocus |= m_proxySurfaceList->get(i)->focused();
--    }
--    return someSurfaceHasFocus;
++    return m_session && m_session->focused();
+ }
  bool Application::fullscreen() const
@@ -512,6 +508,10 @@
          connect(m_session, &SessionInterface::hasClosingSurfacesChanged, this, &Application::updateState);
          connect(m_session, &SessionInterface::focusRequested, this, &Application::focusRequested);
          connect(m_session->surfaceList(), &MirSurfaceListModel::emptyChanged, this, &Application::updateState);
++        connect(m_session, &SessionInterface::focusedChanged, this, [&](bool focused) {
++            qCDebug(QTMIR_APPLICATIONS).nospace() << "Application[" << appId() <<"]::focusedChanged(" << focused << ")";
++            Q_EMIT focusedChanged(focused);
++        });
          if (oldFullscreen != fullscreen())
              Q_EMIT fullscreenChanged(fullscreen());
@@ -852,7 +852,8 @@
+ {
      if (m_proxySurfaceList->rowCount() > 0) {
          DEBUG_MSG << "() - Requesting focus for most recent app surface";
--        m_proxySurfaceList->get(0)->requestFocus();
++        auto surface = static_cast<MirSurfaceInterface*>(m_proxySurfaceList->get(0));
++        surface->requestFocus();
      } else {
          DEBUG_MSG << "() - emitting focusRequested()";
          Q_EMIT focusRequested();
 === modified file 'src/modules/Unity/Application/application.h'
 --- src/modules/Unity/Application/application.h	2016-08-10 06:52:18 +0000
 +++ src/modules/Unity/Application/application.h	2016-12-16 08:22:54 +0000
@@ -31,12 +31,6 @@
  #include "mirsurfacelistmodel.h"
  #include "session_interface.h"
--namespace mir {
--    namespace scene {
--        class Session;
--    }
--}
--
  namespace qtmir
+ {
@@ -109,6 +103,7 @@
      unity::shell::application::MirSurfaceListInterface* surfaceList() const override;
      unity::shell::application::MirSurfaceListInterface* promptSurfaceList() const override;
      int surfaceCount() const override { return surfaceList()->count(); }
++    void close() override;
      ProcessState processState() const { return m_processState; }
      void setProcessState(ProcessState value);
@@ -125,8 +120,6 @@
      pid_t pid() const;
--    void close();
--
      // internal as in "not exposed in unity-api", so qtmir-internal.
      InternalState internalState() const { return m_state; }
 === modified file 'src/modules/Unity/Application/application_manager.cpp'
 --- src/modules/Unity/Application/application_manager.cpp	2016-08-26 09:08:55 +0000
 +++ src/modules/Unity/Application/application_manager.cpp	2016-12-16 08:22:54 +0000
@@ -19,7 +19,7 @@
  #include "application.h"
  #include "applicationinfo.h"
  #include "dbusfocusinfo.h"
--#include "mirfocuscontroller.h"
++#include "mirsurfaceinterface.h"
  #include "session.h"
  #include "sharedwakelock.h"
  #include "proc_info.h"
@@ -31,12 +31,11 @@
  #include "nativeinterface.h"
  #include "sessionauthorizer.h"
  #include "logging.h"
--#include <mirwindowmanager.h>
++
++//miral
++#include <miral/application.h>
  // mir
--#include <mir/scene/surface.h>
--#include <mir/graphics/display.h>
--#include <mir/graphics/display_buffer.h>
  #include <mir/geometry/rectangles.h>
  // Qt
@@ -82,15 +81,8 @@
  void connectToTaskController(ApplicationManager *manager, TaskController *controller)
+ {
--    // TaskController::processStarting blocks Ubuntu-App-Launch from executing the process, have it return
--    // as fast as possible! Using a Queued connection will push an event on the event queue before the
--    // (blocking) event for authorizeSession is pushed on the same queue - so the application's processState
--    // will be up-to-date when authorizeSession is called.
--    //
--    // TODO: Unfortunately making this queued unearths a crash (likely in Qt) (LP: #1616842).
      QObject::connect(controller, &TaskController::processStarting,
                       manager, &ApplicationManager::onProcessStarting);
--
      QObject::connect(controller, &TaskController::processStopped,
                       manager, &ApplicationManager::onProcessStopped);
      QObject::connect(controller, &TaskController::processSuspended,
@@ -115,7 +107,6 @@
          return nullptr;
+     }
--    MirWindowManager *windowManager =  static_cast<MirWindowManager*>(nativeInterface->nativeResourceForIntegration("WindowManager"));
      SessionAuthorizer *sessionAuthorizer = static_cast<SessionAuthorizer*>(nativeInterface->nativeResourceForIntegration("SessionAuthorizer"));
      QSharedPointer<TaskController> taskController(new upstart::TaskController());
@@ -137,9 +128,10 @@
      connectToSessionAuthorizer(appManager, sessionAuthorizer);
      connectToTaskController(appManager, taskController.data());
--    connect(windowManager, &MirWindowManager::sessionAboutToCreateSurface,
--            appManager, &ApplicationManager::onSessionAboutToCreateSurface,
--            Qt::BlockingQueuedConnection);
++//    TODO - re-implement this functionality using the new Mir WindowManagement API
++//    connect(windowManager, &MirWindowManager::sessionAboutToCreateSurface,
++//            appManager, &ApplicationManager::onSessionAboutToCreateSurface,
++//            Qt::BlockingQueuedConnection);
      // Emit signal to notify Upstart that Mir is ready to receive client connections
      // see http://upstart.ubuntu.com/cookbook/#expect-stop
@@ -179,17 +171,6 @@
+ {
      qCDebug(QTMIR_APPLICATIONS) << "ApplicationManager::ApplicationManager (this=%p)" << this;
      setObjectName(QStringLiteral("qtmir::ApplicationManager"));
--
--    /*
--        All begin[...]Rows() and end[...]Rows() functions cause signal emissions which can
--        be processed by slots immediately and then trigger yet more model changes.
--
--        The connection below is queued to avoid stacked model change attempts cause by the above,
--        such as attempting to raise the newly focused application while another one is still
--        getting removed from the model.
--     */
--    connect(MirFocusController::instance(), &MirFocusController::focusedSurfaceChanged,
--        this, &ApplicationManager::updateFocusedApplication, Qt::QueuedConnection);
+ }
  ApplicationManager::~ApplicationManager()
@@ -273,18 +254,12 @@
  QString ApplicationManager::focusedApplicationId() const
+ {
--    Application *focusedApplication = nullptr;
--    auto surface = static_cast<qtmir::MirSurfaceInterface*>(MirFocusController::instance()->focusedSurface());
--    if (surface) {
--        auto self = const_cast<ApplicationManager*>(this);
--        focusedApplication = self->findApplication(surface);
--    }
--
--    if (focusedApplication) {
--        return focusedApplication->appId();
--    } else {
--        return QString();
--    }
++    for (const auto application : m_applications) {
++        if (application->focused()) {
++            return application->appId();
++        }
++    }
++    return QString();
+ }
  /**
@@ -602,16 +577,22 @@
      authorized = true;
+ }
++
++unityapi::ApplicationInfoInterface *ApplicationManager::findApplicationWithSurface(unityapi::MirSurfaceInterface* surface) const
++{
++    if (!surface)
++        return nullptr;
++
++    auto qtmirSurface = static_cast<qtmir::MirSurfaceInterface*>(surface);
++
++    return findApplicationWithPid(miral::pid_of(qtmirSurface->session()->session()));
++}
++
  Application* ApplicationManager::findApplicationWithSession(const std::shared_ptr<ms::Session> &session)
+ {
--    return findApplicationWithSession(session.get());
--}
--
--Application* ApplicationManager::findApplicationWithSession(const ms::Session *session)
--{
      if (!session)
          return nullptr;
--    return findApplicationWithPid(session->process_id());
++    return findApplicationWithPid(miral::pid_of(session));
+ }
  Application* ApplicationManager::findApplicationWithPid(const pid_t pid) const
@@ -640,7 +621,20 @@
      Q_ASSERT(!m_modelUnderChange);
      m_modelUnderChange = true;
--    connect(application, &Application::focusedChanged, this, [this](bool) { onAppDataChanged(RoleFocused); });
++    /*
++        All begin[...]Rows() and end[...]Rows() functions cause signal emissions which can
++        be processed by slots immediately and then trigger yet more model changes.
++
++        The connection below is queued to avoid stacked model change attempts cause by the above,
++        such as attempting to raise the newly focused application while another one is still
++        getting removed from the model.
++     */
++    // TODO: That might not be the case anymore with miral. Investigate if we can do a direct connection now
++    connect(application, &Application::focusedChanged, this, [this](bool) {
++        onAppDataChanged(RoleFocused);
++        Q_EMIT focusedApplicationIdChanged();
++    }, Qt::QueuedConnection);
++
      connect(application, &Application::stateChanged, this, [this](Application::State) { onAppDataChanged(RoleState); });
      connect(application, &Application::closing, this, [this, application]() { onApplicationClosing(application); });
      connect(application, &unityapi::ApplicationInfoInterface::focusRequested, this, [this, application]() {
@@ -805,35 +799,6 @@
+     }
+ }
--void ApplicationManager::updateFocusedApplication()
--{
--    Application *focusedApplication = nullptr;
--    Application *previouslyFocusedApplication = nullptr;
--
--    auto surface = static_cast<qtmir::MirSurfaceInterface*>(MirFocusController::instance()->focusedSurface());
--    if (surface) {
--        focusedApplication = findApplication(surface);
--    }
--
--    surface = static_cast<qtmir::MirSurfaceInterface*>(MirFocusController::instance()->previouslyFocusedSurface());
--    if (surface) {
--        previouslyFocusedApplication = findApplication(surface);
--    }
--
--    if (focusedApplication != previouslyFocusedApplication) {
--        if (focusedApplication) {
--            DEBUG_MSG << "() focused " << focusedApplication->appId();
--            Q_EMIT focusedApplication->focusedChanged(true);
--            this->move(this->m_applications.indexOf(focusedApplication), 0);
--        }
--        if (previouslyFocusedApplication) {
--            DEBUG_MSG << "() unfocused " << previouslyFocusedApplication->appId();
--            Q_EMIT previouslyFocusedApplication->focusedChanged(false);
--        }
--        Q_EMIT focusedApplicationIdChanged();
--    }
--}
--
  Application *ApplicationManager::findApplication(qtmir::MirSurfaceInterface* surface)
+ {
      Q_FOREACH (Application *app, m_applications) {
 === modified file 'src/modules/Unity/Application/application_manager.h'
 --- src/modules/Unity/Application/application_manager.h	2016-08-08 13:10:40 +0000
 +++ src/modules/Unity/Application/application_manager.h	2016-12-16 08:22:54 +0000
@@ -24,13 +24,13 @@
  #include <QObject>
  #include <QStringList>
--// Unity API
--#include <unity/shell/application/ApplicationManagerInterface.h>
--
  // local
  #include "application.h"
  #include "taskcontroller.h"
++// Unity API
++#include <unity/shell/application/ApplicationManagerInterface.h>
++
  namespace mir {
      namespace scene {
          class Session;
@@ -51,7 +51,6 @@
  class DBusFocusInfo;
  class DBusWindowStack;
--class MirSurfaceManager;
  class ProcInfo;
  class SharedWakelock;
  class SettingsInterface;
@@ -80,10 +79,11 @@
              QObject *parent = 0);
      virtual ~ApplicationManager();
--    // ApplicationManagerInterface
++    // unity::shell::application::ApplicationManagerInterface
      QString focusedApplicationId() const override;
      Q_INVOKABLE qtmir::Application* get(int index) const override;
      Q_INVOKABLE qtmir::Application* findApplication(const QString &appId) const override;
++    unity::shell::application::ApplicationInfoInterface *findApplicationWithSurface(unity::shell::application::MirSurfaceInterface* surface) const override;
      Q_INVOKABLE bool requestFocusApplication(const QString &appId) override;
      Q_INVOKABLE qtmir::Application* startApplication(const QString &appId, const QStringList &arguments = QStringList()) override;
      Q_INVOKABLE bool stopApplication(const QString &appId) override;
@@ -117,14 +117,13 @@
      void onSessionAboutToCreateSurface(const std::shared_ptr<mir::scene::Session> &session,
                                         int type, QSize &size);
      void onApplicationClosing(Application *application);
--    void updateFocusedApplication();
  private:
++    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session);
      void setFocused(Application *application);
      void add(Application *application);
      void remove(Application* application);
--    Application* findApplicationWithSession(const std::shared_ptr<mir::scene::Session> &session);
--    Application* findApplicationWithSession(const mir::scene::Session *session);
++
      QModelIndex findIndex(Application* application);
      void resumeApplication(Application *application);
      QString toString() const;
@@ -146,7 +145,6 @@
      friend class Application;
      friend class DBusWindowStack;
--    friend class MirSurfaceManager;
      friend class SessionManager;
  };
 === modified file 'src/modules/Unity/Application/dbusfocusinfo.cpp'
 --- src/modules/Unity/Application/dbusfocusinfo.cpp	2016-08-30 12:32:13 +0000
 +++ src/modules/Unity/Application/dbusfocusinfo.cpp	2016-12-16 08:22:54 +0000
@@ -75,29 +75,23 @@
  SessionInterface* DBusFocusInfo::findSessionWithPid(const QSet<pid_t> &pidSet)
+ {
      Q_FOREACH (Application* application, m_applications) {
--        SessionInterface *sessionWithPid = findSessionWithPid(application->session(), pidSet);
--        if (sessionWithPid) {
--            return sessionWithPid;
++        auto session = application->session();
++        if (pidSet.contains(session->pid())) {
++            return session;
++        }
++        SessionInterface *chosenChildSession = nullptr;
++        session->foreachChildSession([&](SessionInterface* childSession) {
++            if (pidSet.contains(childSession->pid())) {
++                chosenChildSession = childSession;
++            }
++        });
++        if (chosenChildSession) {
++            return chosenChildSession;
+         }
+     }
      return nullptr;
+ }
--SessionInterface* DBusFocusInfo::findSessionWithPid(SessionInterface* session, const QSet<pid_t> &pidSet)
--{
--    if (pidSet.contains(session->pid())) {
--        return session;
--    }
--
--    SessionInterface *sessionWithPid = nullptr;
--    session->foreachChildSession([&](SessionInterface* childSession) {
--        if (!sessionWithPid) {
--            sessionWithPid = findSessionWithPid(childSession, pidSet);
--        }
--    });
--    return sessionWithPid;
--}
--
  bool DBusFocusInfo::isSurfaceFocused(const QString &serializedId)
+ {
      // TODO: Implement a penalty for negative queries, such as stalling for some time before answering
 === modified file 'src/modules/Unity/Application/dbusfocusinfo.h'
 --- src/modules/Unity/Application/dbusfocusinfo.h	2016-08-30 12:29:32 +0000
 +++ src/modules/Unity/Application/dbusfocusinfo.h	2016-12-16 08:22:54 +0000
@@ -54,7 +54,6 @@
  private:
      QSet<pid_t> fetchAssociatedPids(pid_t pid);
      SessionInterface* findSessionWithPid(const QSet<pid_t> &pidSet);
--    SessionInterface* findSessionWithPid(SessionInterface* session, const QSet<pid_t> &pidSet);
      MirSurfaceInterface *findQmlSurface(const QString &serializedId);
      const QList<Application*> &m_applications;
 === removed file 'src/modules/Unity/Application/mirfocuscontroller.cpp'
 --- src/modules/Unity/Application/mirfocuscontroller.cpp	2016-04-05 18:58:38 +0000
 +++ src/modules/Unity/Application/mirfocuscontroller.cpp	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
--/*
-- * 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/>.
-- */
--
--#include "mirfocuscontroller.h"
--
--#include "mirsurfaceinterface.h"
--
--// mirserver
--#include <logging.h>
--
--namespace unityapp = unity::shell::application;
--using namespace qtmir;
--
--#define DEBUG_MSG qCDebug(QTMIR_SURFACES).nospace() << "MirFocusController::" << __func__
--
--MirFocusController *MirFocusController::m_instance = nullptr;
--
--void MirFocusController::setFocusedSurface(unityapp::MirSurfaceInterface *unityAppSurface)
--{
--    auto surface = static_cast<qtmir::MirSurfaceInterface*>(unityAppSurface);
--
--    if (m_focusedSurface == surface) {
--        return;
--    }
--
--    DEBUG_MSG << "(" << surface << ")";
--
--    m_previouslyFocusedSurface = m_focusedSurface;
--    m_focusedSurface = surface;
--
--    if (m_previouslyFocusedSurface) {
--        m_previouslyFocusedSurface->setFocused(false);
--    }
--
--    if (m_focusedSurface) {
--        m_focusedSurface->setFocused(true);
--        m_focusedSurface->raise();
--    }
--
--    if (m_previouslyFocusedSurface != m_focusedSurface) {
--        Q_EMIT focusedSurfaceChanged();
--    }
--}
--
--unity::shell::application::MirSurfaceInterface* MirFocusController::focusedSurface() const
--{
--    return m_focusedSurface;
--}
--
--MirFocusController* MirFocusController::instance()
--{
--    if (!m_instance) {
--        m_instance = new MirFocusController;
--    }
--    return m_instance;
--}
 === removed file 'src/modules/Unity/Application/mirfocuscontroller.h'
 --- src/modules/Unity/Application/mirfocuscontroller.h	2016-03-28 18:02:26 +0000
 +++ src/modules/Unity/Application/mirfocuscontroller.h	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
--/*
-- * 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/>.
-- */
--
--#ifndef QTMIR_MIRFOCUSCONTROLLER_H
--#define QTMIR_MIRFOCUSCONTROLLER_H
--
--// unity-api
--#include <unity/shell/application/MirFocusControllerInterface.h>
--
--#include <QPointer>
--
--#include "mirsurfaceinterface.h"
--
--namespace qtmir {
--
--class MirSurfaceInterface;
--
--class MirFocusController : public unity::shell::application::MirFocusControllerInterface
--{
--    Q_OBJECT
--public:
--    MirFocusController(){}
--    static MirFocusController* instance();
--
--    void setFocusedSurface(unity::shell::application::MirSurfaceInterface *surface) override;
--    unity::shell::application::MirSurfaceInterface* focusedSurface() const override;
--    MirSurfaceInterface* previouslyFocusedSurface() { return m_previouslyFocusedSurface.data(); }
--private:
--    static MirFocusController *m_instance;
--    QPointer<MirSurfaceInterface> m_previouslyFocusedSurface;
--    QPointer<MirSurfaceInterface> m_focusedSurface;
--};
--
--} // namespace qtmir
--
--#endif // QTMIR_MIRFOCUSCONTROLLER_H
 === modified file 'src/modules/Unity/Application/mirsurface.cpp'
 --- src/modules/Unity/Application/mirsurface.cpp	2016-10-11 20:50:50 +0000
 +++ src/modules/Unity/Application/mirsurface.cpp	2016-12-16 08:22:54 +0000
@@ -16,11 +16,14 @@
  #include "mirsurface.h"
  #include "mirsurfacelistmodel.h"
++#include "namedcursor.h"
++#include "session_interface.h"
  #include "timer.h"
  #include "timestamp.h"
  // from common dir
  #include <debughelpers.h>
++#include "mirqtconversion.h"
  // mirserver
  #include <eventbuilder.h>
@@ -29,11 +32,9 @@
  // Mir
  #include <mir/geometry/rectangle.h>
--#include <mir/events/event_builders.h>
--#include <mir/shell/shell.h>
  #include <mir/scene/surface.h>
--#include <mir/scene/session.h>
--#include <mir_toolkit/event.h>
++#include <mir/scene/surface_observer.h>
++#include <mir/version.h>
  // mirserver
  #include <logging.h>
@@ -42,60 +43,125 @@
  #include <QQmlEngine>
  #include <QScreen>
++// std
++#include <limits>
++
  using namespace qtmir;
  #define DEBUG_MSG qCDebug(QTMIR_SURFACES).nospace() << "MirSurface[" << (void*)this << "," << appId() << "]::" << __func__
  #define WARNING_MSG qCWarning(QTMIR_SURFACES).nospace() << "MirSurface[" << (void*)this << "," << appId() << "]::" << __func__
--MirSurface::MirSurface(std::shared_ptr<mir::scene::Surface> surface,
--        const QString& persistentId,
--        SessionInterface* session,
--        mir::shell::Shell* shell,
--        std::shared_ptr<SurfaceObserver> observer,
--        const CreationHints &creationHints)
++namespace {
++
++enum class DirtyState {
++    Clean = 0,
++    Name = 1 << 1,
++    Type = 1 << 2,
++    State = 1 << 3,
++    RestoreRect = 1 << 4,
++    Children = 1 << 5,
++    MinSize = 1 << 6,
++    MaxSize = 1 << 7,
++};
++Q_DECLARE_FLAGS(DirtyStates, DirtyState)
++
++} // namespace {
++
++class MirSurface::SurfaceObserverImpl : public SurfaceObserver, public mir::scene::SurfaceObserver
++{
++public:
++    SurfaceObserverImpl();
++    virtual ~SurfaceObserverImpl();
++
++    void setListener(QObject *listener);
++
++    void attrib_changed(MirSurfaceAttrib, int) override;
++    void resized_to(mir::geometry::Size const&) override;
++    void moved_to(mir::geometry::Point const&) override {}
++    void hidden_set_to(bool) override {}
++
++    // Get new frame notifications from Mir, called from a Mir thread.
++    void frame_posted(int frames_available, mir::geometry::Size const& size ) override;
++
++    void alpha_set_to(float) override {}
++    void transformation_set_to(glm::mat4 const&) override {}
++    void reception_mode_set_to(mir::input::InputReceptionMode) override {}
++    void cursor_image_set_to(mir::graphics::CursorImage const&) override;
++    void orientation_set_to(MirOrientation) override {}
++    void client_surface_close_requested() override {}
++    void keymap_changed(MirInputDeviceId, std::string const& model, std::string const& layout,
++                        std::string const& variant, std::string const& options) override;
++    void renamed(char const * name) override;
++    void cursor_image_removed() override;
++
++#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
++    void placed_relative(mir::geometry::Rectangle const& placement) override;
++#endif
++
++private:
++    QCursor createQCursorFromMirCursorImage(const mir::graphics::CursorImage &cursorImage);
++    QObject *m_listener;
++    bool m_framesPosted;
++    QMap<QByteArray, Qt::CursorShape> m_cursorNameToShape;
++};
++
++
++MirSurface::MirSurface(NewWindow newWindowInfo,
++        WindowControllerInterface* controller,
++        SessionInterface *session)
      : MirSurfaceInterface()
--    , m_surface(surface)
++    , m_window{newWindowInfo.windowInfo.window()}
++    , m_extraInfo{getExtraInfo(newWindowInfo.windowInfo)}
++    , m_name{QString::fromStdString(newWindowInfo.windowInfo.name())}
++    , m_type{newWindowInfo.windowInfo.type()}
++    , m_minWidth{newWindowInfo.windowInfo.min_width().as_int()}
++    , m_minHeight{newWindowInfo.windowInfo.min_height().as_int()}
++    , m_maxWidth{newWindowInfo.windowInfo.max_width().as_int()}
++    , m_maxHeight{newWindowInfo.windowInfo.max_height().as_int()}
++    , m_incWidth{newWindowInfo.windowInfo.width_inc().as_int()}
++    , m_incHeight{newWindowInfo.windowInfo.height_inc().as_int()}
++    , m_surface(newWindowInfo.surface)
      , m_session(session)
--    , m_shell(shell)
--    , m_persistentId(persistentId)
--    , m_firstFrameDrawn(false)
++    , m_controller(controller)
      , m_orientationAngle(Mir::Angle0)
      , m_textureUpdated(false)
      , m_currentFrameNumber(0)
++    , m_visible(newWindowInfo.windowInfo.is_visible())
      , m_live(true)
++    , m_surfaceObserver(std::make_shared<SurfaceObserverImpl>())
++    , m_position(toQPoint(m_window.top_left()))
++    , m_size(toQSize(m_window.size()))
++    , m_state(toQtState(newWindowInfo.windowInfo.state()))
      , m_shellChrome(Mir::NormalChrome)
+ {
--    DEBUG_MSG << "()";
--
--    m_minimumWidth = creationHints.minWidth;
--    m_minimumHeight = creationHints.minHeight;
--    m_maximumWidth = creationHints.maxWidth;
--    m_maximumHeight = creationHints.maxHeight;
--    m_widthIncrement = creationHints.widthIncrement;
--    m_heightIncrement = creationHints.heightIncrement;
--    m_shellChrome = creationHints.shellChrome;
--
--    m_surfaceObserver = observer;
--    if (observer) {
--        connect(observer.get(), &SurfaceObserver::framesPosted, this, &MirSurface::onFramesPostedObserved);
--        connect(observer.get(), &SurfaceObserver::attributeChanged, this, &MirSurface::onAttributeChanged);
--        connect(observer.get(), &SurfaceObserver::nameChanged, this, &MirSurface::nameChanged);
--        connect(observer.get(), &SurfaceObserver::cursorChanged, this, &MirSurface::setCursor);
--        connect(observer.get(), &SurfaceObserver::minimumWidthChanged, this, &MirSurface::setMinimumWidth);
--        connect(observer.get(), &SurfaceObserver::minimumHeightChanged, this, &MirSurface::setMinimumHeight);
--        connect(observer.get(), &SurfaceObserver::maximumWidthChanged, this, &MirSurface::setMaximumWidth);
--        connect(observer.get(), &SurfaceObserver::maximumHeightChanged, this, &MirSurface::setMaximumHeight);
--        connect(observer.get(), &SurfaceObserver::widthIncrementChanged, this, &MirSurface::setWidthIncrement);
--        connect(observer.get(), &SurfaceObserver::heightIncrementChanged, this, &MirSurface::setHeightIncrement);
--        connect(observer.get(), &SurfaceObserver::shellChromeChanged, this, [&](MirShellChrome shell_chrome) {
--            setShellChrome(static_cast<Mir::ShellChrome>(shell_chrome));
--        });
--        connect(observer.get(), &SurfaceObserver::inputBoundsChanged, this, &MirSurface::setInputBounds);
--        connect(observer.get(), &SurfaceObserver::confinesMousePointerChanged, this, &MirSurface::confinesMousePointerChanged);
--        observer->setListener(this);
--    }
--
--    connect(session, &QObject::destroyed, this, &MirSurface::onSessionDestroyed);
++    DEBUG_MSG << "("
++        << "type=" << mirSurfaceTypeToStr(m_type)
++        << ",state=" << unityapiMirStateToStr(m_state)
++        << ")";
++
++    SurfaceObserver::registerObserverForSurface(m_surfaceObserver.get(), m_surface.get());
++    m_surface->add_observer(m_surfaceObserver);
++
++    //m_shellChrome = creationHints.shellChrome; TODO - where will this come from now?
++
++    connect(m_surfaceObserver.get(), &SurfaceObserver::framesPosted, this, &MirSurface::onFramesPostedObserved);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::attributeChanged, this, &MirSurface::onAttributeChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::nameChanged, this, &MirSurface::onNameChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::cursorChanged, this, &MirSurface::setCursor);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::minimumWidthChanged, this, &MirSurface::onMinimumWidthChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::minimumHeightChanged, this, &MirSurface::onMinimumHeightChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::maximumWidthChanged, this, &MirSurface::onMaximumWidthChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::maximumHeightChanged, this, &MirSurface::onMaximumHeightChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::widthIncrementChanged, this, &MirSurface::onWidthIncrementChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::heightIncrementChanged, this, &MirSurface::onHeightIncrementChanged);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::shellChromeChanged, this, [&](MirShellChrome shell_chrome) {
++        setShellChrome(static_cast<Mir::ShellChrome>(shell_chrome));
++    });
++    connect(m_surfaceObserver.get(), &SurfaceObserver::inputBoundsChanged, this, &MirSurface::setInputBounds);
++    connect(m_surfaceObserver.get(), &SurfaceObserver::confinesMousePointerChanged, this, &MirSurface::confinesMousePointerChanged);
++    m_surfaceObserver->setListener(this);
++
++    //connect(session, &QObject::destroyed, this, &MirSurface::onSessionDestroyed); // TODO try using Shared pointer for lifecycle
      connect(session, &SessionInterface::stateChanged, this, [this]() {
          if (clientIsRunning() && m_pendingResize.isValid()) {
              resize(m_pendingResize.width(), m_pendingResize.height());
@@ -124,10 +190,8 @@
      setCloseTimer(new Timer);
--    QTimer::singleShot(m_minimumAgeForOcclusion, this, [this]() {
--        m_oldEnoughToBeOccluded = true;
--        updateVisibility();
--    });
++    m_requestedPosition.rx() = std::numeric_limits<int>::min();
++    m_requestedPosition.ry() = std::numeric_limits<int>::min();
+ }
  MirSurface::~MirSurface()
@@ -146,11 +210,6 @@
  void MirSurface::onFramesPostedObserved()
+ {
--    if (!m_firstFrameDrawn) {
--        m_firstFrameDrawn = true;
--        Q_EMIT firstFrameDrawn();
--    }
--
      // restart the frame dropper so that items have enough time to render the next frame.
      m_frameDropperTimer.start();
@@ -164,14 +223,6 @@
          DEBUG_MSG << " type = " << mirSurfaceTypeToStr(state());
          Q_EMIT typeChanged(type());
          break;
--    case mir_surface_attrib_state:
--        DEBUG_MSG << " state = " << mirSurfaceStateToStr(state());
--        Q_EMIT stateChanged(state());
--        break;
--    case mir_surface_attrib_visibility:
--        DEBUG_MSG << " visible = " << visible();
--        Q_EMIT visibleChanged(visible());
--        break;
      default:
          break;
+     }
@@ -179,7 +230,7 @@
  Mir::Type MirSurface::type() const
+ {
--    switch (m_surface->type()) {
++    switch (m_type) {
      case mir_surface_type_normal:
          return Mir::NormalType;
@@ -218,7 +269,7 @@
      const void* const userId = (void*)123;  // TODO: Multimonitor support
--    int framesPending = m_surface->buffers_ready_for_compositor(userId);
++    const int framesPending = m_surface->buffers_ready_for_compositor(userId);
      if (framesPending > 0) {
          m_textureUpdated = false;
@@ -290,7 +341,7 @@
          texture->setBuffer(renderables[0]->buffer());
          ++m_currentFrameNumber;
--        if (texture->textureSize() != m_size) {
++        if (texture->textureSize() != size()) {
              m_size = texture->textureSize();
              QMetaObject::invokeMethod(this, "emitSizeChanged", Qt::QueuedConnection);
+         }
@@ -325,6 +376,8 @@
      if (m_focused == value)
          return;
++    DEBUG_MSG << "(" << value << ")";
++
      m_focused = value;
      Q_EMIT focusedChanged(value);
+ }
@@ -358,17 +411,30 @@
          return;
+     }
++    // TODO Figure out what to do here
++    /*
      if (m_activelyFocusedViews.isEmpty()) {
          DEBUG_MSG << "() unfocused";
--        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_unfocused);
++        m_controller->setActiveFocus(m_window, false);
      } else {
          DEBUG_MSG << "() focused";
--        m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_focus, mir_surface_focused);
++        m_controller->setActiveFocus(m_window, true);
+     }
++    */
      m_neverSetSurfaceFocus = false;
+ }
++void MirSurface::updateVisible()
++{
++    const bool visible = !(m_state == Mir::HiddenState || m_state == Mir::MinimizedState) && m_surface->visible();
++
++    if (m_visible != visible) {
++        m_visible = visible;
++        Q_EMIT visibleChanged(visible);
++    }
++}
++
  void MirSurface::close()
+ {
      if (m_closingState != NotClosing) {
@@ -381,8 +447,8 @@
      Q_EMIT closeRequested();
      m_closeTimer->start();
--    if (m_surface) {
--        m_surface->request_client_surface_close();
++    if (m_window) {
++        m_controller->requestClose(m_window);
+     }
+ }
@@ -393,19 +459,28 @@
          return;
+     }
--    int mirWidth = m_surface->size().width.as_int();
--    int mirHeight = m_surface->size().height.as_int();
--
--    bool mirSizeIsDifferent = width != mirWidth || height != mirHeight;
++    bool mirSizeIsDifferent = width != m_size.width() || height != m_size.height();
      if (mirSizeIsDifferent) {
--        mir::geometry::Size newMirSize(width, height);
--        m_surface->resize(newMirSize);
--        DEBUG_MSG << " old (" << mirWidth << "," << mirHeight << ")"
++        m_controller->resize(m_window, QSize(width, height));
++        DEBUG_MSG << " old (" << m_size.width() << "," << m_size.height() << ")"
                    << ", new (" << width << "," << height << ")";
+     }
+ }
++QPoint MirSurface::position() const
++{
++    return m_position;
++}
++
++void MirSurface::setPosition(const QPoint newPosition)
++{
++    if (m_position != newPosition) {
++        m_position = newPosition;
++        Q_EMIT positionChanged(newPosition);
++    }
++}
++
  QSize MirSurface::size() const
+ {
      return m_size;
@@ -413,26 +488,7 @@
  Mir::State MirSurface::state() const
+ {
--    switch (m_surface->state()) {
--    case mir_surface_state_unknown:
--        return Mir::UnknownState;
--    case mir_surface_state_restored:
--        return Mir::RestoredState;
--    case mir_surface_state_minimized:
--        return Mir::MinimizedState;
--    case mir_surface_state_maximized:
--        return Mir::MaximizedState;
--    case mir_surface_state_vertmaximized:
--        return Mir::VertMaximizedState;
--    case mir_surface_state_fullscreen:
--        return Mir::FullscreenState;
--    case mir_surface_state_horizmaximized:
--        return Mir::HorizMaximizedState;
--    case mir_surface_state_hidden:
--        return Mir::HiddenState;
--    default:
--        return Mir::UnknownState;
--    }
++    return m_state;
+ }
  Mir::OrientationAngle MirSurface::orientationAngle() const
@@ -477,54 +533,18 @@
  QString MirSurface::name() const
+ {
--    return QString::fromStdString(m_surface->name());
++    return m_name;
+ }
  QString MirSurface::persistentId() const
+ {
--    return m_persistentId;
++    return m_extraInfo->persistentId;
+ }
--void MirSurface::setState(Mir::State qmlState)
++void MirSurface::requestState(Mir::State state)
+ {
--    int mirState;
--
--    switch (qmlState) {
--    default:
--    case Mir::UnknownState:
--        mirState = mir_surface_state_unknown;
--        break;
--
--    case Mir::RestoredState:
--        mirState = mir_surface_state_restored;
--        break;
--
--    case Mir::MinimizedState:
--        mirState = mir_surface_state_minimized;
--        break;
--
--    case Mir::MaximizedState:
--        mirState = mir_surface_state_maximized;
--        break;
--
--    case Mir::VertMaximizedState:
--        mirState = mir_surface_state_vertmaximized;
--        break;
--
--    case Mir::FullscreenState:
--        mirState = mir_surface_state_fullscreen;
--        break;
--
--    case Mir::HorizMaximizedState:
--        mirState = mir_surface_state_horizmaximized;
--        break;
--
--    case Mir::HiddenState:
--        mirState = mir_surface_state_hidden;
--        break;
--    }
--
--    m_shell->set_surface_attribute(m_session->session(), m_surface, mir_surface_attrib_state, mirState);
++    DEBUG_MSG << "(" << unityapiMirStateToStr(state) << ")";
++    m_controller->requestState(m_window, state);
+ }
  void MirSurface::setLive(bool value)
@@ -546,69 +566,78 @@
  bool MirSurface::visible() const
+ {
--    return m_surface->query(mir_surface_attrib_visibility) == mir_surface_visibility_exposed;
++    return m_visible;
+ }
--
++#include <mir_toolkit/event.h>
  void MirSurface::mousePressEvent(QMouseEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::mouseMoveEvent(QMouseEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::mouseReleaseEvent(QMouseEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::hoverEnterEvent(QHoverEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::hoverLeaveEvent(QHoverEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::hoverMoveEvent(QHoverEvent *event)
+ {
      auto ev = EventBuilder::instance()->reconstructMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::wheelEvent(QWheelEvent *event)
+ {
      auto ev = EventBuilder::instance()->makeMirEvent(event);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirPointerEvent const*>(ev.get());
++    m_controller->deliverPointerEvent(m_window, ev1);
      event->accept();
+ }
  void MirSurface::keyPressEvent(QKeyEvent *qtEvent)
+ {
      auto ev = EventBuilder::instance()->makeMirEvent(qtEvent);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
++    m_controller->deliverKeyboardEvent(m_window, ev1);
      qtEvent->accept();
+ }
  void MirSurface::keyReleaseEvent(QKeyEvent *qtEvent)
+ {
      auto ev = EventBuilder::instance()->makeMirEvent(qtEvent);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirKeyboardEvent const*>(ev.get());
++    m_controller->deliverKeyboardEvent(m_window, ev1);
      qtEvent->accept();
+ }
@@ -618,15 +647,16 @@
                              ulong timestamp)
+ {
      auto ev = EventBuilder::instance()->makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
--    m_surface->consume(ev.get());
++    auto ev1 = reinterpret_cast<MirTouchEvent const*>(ev.get());
++    m_controller->deliverTouchEvent(m_window, ev1);
+ }
  bool MirSurface::clientIsRunning() const
+ {
      return (m_session &&
--            (m_session->state() == Session::State::Running
--             || m_session->state() == Session::State::Starting
--             || m_session->state() == Session::State::Suspending))
++            (m_session->state() == SessionInterface::State::Running
++             || m_session->state() == SessionInterface::State::Starting
++             || m_session->state() == SessionInterface::State::Suspending))
          || !m_session;
+ }
@@ -654,39 +684,40 @@
              deleteLater();
+         }
+     }
--    updateVisibility();
++    updateExposure();
      setViewActiveFocus(viewId, false);
+ }
--void MirSurface::setViewVisibility(qintptr viewId, bool visible)
++void MirSurface::setViewExposure(qintptr viewId, bool exposed)
+ {
      if (!m_views.contains(viewId)) return;
--    m_views[viewId].visible = visible;
--    updateVisibility();
++    m_views[viewId].exposed = exposed;
++    updateExposure();
+ }
--void MirSurface::updateVisibility()
++void MirSurface::updateExposure()
+ {
--    bool newVisible = false;
--
--    if (m_oldEnoughToBeOccluded) {
--        QHashIterator<qintptr, View> i(m_views);
--        while (i.hasNext()) {
--            i.next();
--            newVisible |= i.value().visible;
--        }
--    } else {
--        // Surface is too young to get occluded. Let it remain exposed for a bit to ensure that it displays
--        // a properly formed UI on start up.
--        newVisible = true;
--    }
--
--    if (newVisible != visible()) {
--        DEBUG_MSG << "(" << newVisible << ")";
++    // Only update exposure after client has swapped a frame (aka surface is "ready"). MirAL only considers
++    // a surface visible after it has drawn something
++    if (!m_ready) {
++        return;
++    }
++
++    bool newExposed = false;
++    QHashIterator<qintptr, View> i(m_views);
++    while (i.hasNext()) {
++        i.next();
++        newExposed |= i.value().exposed;
++    }
++
++    const bool oldExposed = (m_surface->query(mir_surface_attrib_visibility) == mir_surface_visibility_exposed);
++
++    if (newExposed != oldExposed) {
++        DEBUG_MSG << "(" << newExposed << ")";
          m_surface->configure(mir_surface_attrib_visibility,
--                             newVisible ? mir_surface_visibility_exposed : mir_surface_visibility_occluded);
++                             newExposed ? mir_surface_visibility_exposed : mir_surface_visibility_occluded);
+     }
+ }
@@ -777,15 +808,6 @@
+     }
+ }
--void MirSurface::setScreen(QScreen *screen)
--{
--    using namespace mir::geometry;
--    // in Mir, this means moving the surface in Mir's scene to the matching display
--    auto targetScreenTopLeftPx = screen->geometry().topLeft(); // * screen->devicePixelRatio(); GERRY?
--    DEBUG_MSG << "moved to" << targetScreenTopLeftPx << "px";
--    m_surface->move_to(Point{ X{targetScreenTopLeftPx.x()}, Y{targetScreenTopLeftPx.y()} });
--}
--
  bool MirSurface::inputAreaContains(const QPoint &point) const
+ {
      bool result;
@@ -804,6 +826,30 @@
      return result;
+ }
++void MirSurface::updateState(Mir::State newState)
++{
++    if (newState == m_state) {
++        return;
++    }
++    DEBUG_MSG << "(" << unityapiMirStateToStr(newState) << ")";
++
++    m_state = newState;
++    Q_EMIT stateChanged(state());
++
++    // Mir determines visibility from the state, it may have changed
++    updateVisible();
++}
++
++void MirSurface::setReady()
++{
++    if (!m_ready) {
++        DEBUG_MSG << "()";
++        m_ready = true;
++        Q_EMIT ready();
++        updateExposure();
++    }
++}
++
  void MirSurface::setCursor(const QCursor &cursor)
+ {
      DEBUG_MSG << "(" << qtCursorShapeToStr(cursor.shape()) << ")";
@@ -814,80 +860,32 @@
  int MirSurface::minimumWidth() const
+ {
--    return m_minimumWidth;
++    return m_minWidth;
+ }
  int MirSurface::minimumHeight() const
+ {
--    return m_minimumHeight;
++    return m_minHeight;
+ }
  int MirSurface::maximumWidth() const
+ {
--    return m_maximumWidth;
++    return m_maxWidth;
+ }
  int MirSurface::maximumHeight() const
+ {
--    return m_maximumHeight;
++    return m_maxHeight;
+ }
  int MirSurface::widthIncrement() const
+ {
--    return m_widthIncrement;
++    return m_incWidth;
+ }
  int MirSurface::heightIncrement() const
+ {
--    return m_heightIncrement;
--}
--
--void MirSurface::setMinimumWidth(int value)
--{
--    if (value != m_minimumWidth) {
--        m_minimumWidth = value;
--        Q_EMIT minimumWidthChanged(value);
--    }
--}
--
--void MirSurface::setMinimumHeight(int value)
--{
--    if (value != m_minimumHeight) {
--        m_minimumHeight = value;
--        Q_EMIT minimumHeightChanged(value);
--    }
--}
--
--void MirSurface::setMaximumWidth(int value)
--{
--    if (value != m_maximumWidth) {
--        m_maximumWidth = value;
--        Q_EMIT maximumWidthChanged(value);
--    }
--}
--
--void MirSurface::setMaximumHeight(int value)
--{
--    if (value != m_maximumHeight) {
--        m_maximumHeight = value;
--        Q_EMIT maximumHeightChanged(value);
--    }
--}
--
--void MirSurface::setWidthIncrement(int value)
--{
--    if (value != m_widthIncrement) {
--        m_widthIncrement = value;
--        Q_EMIT widthIncrementChanged(value);
--    }
--}
--
--void MirSurface::setHeightIncrement(int value)
--{
--    if (value != m_heightIncrement) {
--        m_heightIncrement = value;
--        Q_EMIT heightIncrementChanged(value);
--    }
++    return m_incHeight;
+ }
  bool MirSurface::focused() const
@@ -905,16 +903,12 @@
      return m_surface->confine_pointer_state() == mir_pointer_confined_to_surface;
+ }
--void MirSurface::requestFocus()
--{
--    DEBUG_MSG << "()";
--    Q_EMIT focusRequested();
--}
--
--void MirSurface::raise()
--{
--    DEBUG_MSG << "()";
--    Q_EMIT raiseRequested();
++void MirSurface::activate()
++{
++    DEBUG_MSG << "()";
++    if (m_live) {
++        m_controller->activate(m_window);
++    }
+ }
  void MirSurface::onCloseTimedOut()
@@ -925,7 +919,9 @@
      m_closingState = CloseOverdue;
--    m_session->session()->destroy_surface(m_surface);
++    if (m_live) {
++        m_controller->forceClose(m_window);
++    }
+ }
  void MirSurface::setCloseTimer(AbstractTimer *timer)
@@ -947,6 +943,11 @@
+     }
+ }
++std::shared_ptr<SurfaceObserver> MirSurface::surfaceObserver() const
++{
++    return m_surfaceObserver;
++}
++
  void MirSurface::setInputBounds(const QRect &rect)
+ {
      if (m_inputBounds != rect) {
@@ -955,3 +956,230 @@
          Q_EMIT inputBoundsChanged(m_inputBounds);
+     }
+ }
++
++QPoint MirSurface::requestedPosition() const
++{
++    return m_requestedPosition;
++}
++
++void MirSurface::setRequestedPosition(const QPoint &point)
++{
++    if (point != m_requestedPosition) {
++        m_requestedPosition = point;
++        Q_EMIT requestedPositionChanged(m_requestedPosition);
++
++        if (m_live) {
++            m_controller->move(m_window, m_requestedPosition);
++        }
++    }
++}
++
++void MirSurface::onMinimumWidthChanged(int minWidth)
++{
++    if (m_minWidth != minWidth)
++    {
++        m_minWidth = minWidth;
++        Q_EMIT minimumWidthChanged(minWidth);
++    }
++}
++
++void MirSurface::onMinimumHeightChanged(int minHeight)
++{
++    if (m_minHeight != minHeight)
++    {
++        m_minHeight = minHeight;
++        Q_EMIT minimumHeightChanged(minHeight);
++    }
++}
++
++void MirSurface::onMaximumWidthChanged(int maxWidth)
++{
++    if (m_maxWidth != maxWidth)
++    {
++        m_maxWidth = maxWidth;
++        Q_EMIT maximumWidthChanged(maxWidth);
++    }
++}
++
++void MirSurface::onMaximumHeightChanged(int maxHeight)
++{
++    if (m_maxHeight != maxHeight)
++    {
++        m_maxHeight = maxHeight;
++        Q_EMIT maximumHeightChanged(maxHeight);
++    }
++}
++
++void MirSurface::onWidthIncrementChanged(int incWidth)
++{
++    if (m_incWidth != incWidth)
++    {
++        m_incWidth = incWidth;
++        Q_EMIT widthIncrementChanged(incWidth);
++    }
++}
++
++void MirSurface::onHeightIncrementChanged(int incHeight)
++{
++    if (m_incHeight != incHeight)
++    {
++        m_incHeight = incHeight;
++        Q_EMIT heightIncrementChanged(incHeight);
++    }
++}
++
++void MirSurface::onNameChanged(const QString &name)
++{
++    if (m_name != name)
++    {
++        m_name = name;
++        Q_EMIT nameChanged(name);
++    }
++}
++
++MirSurface::SurfaceObserverImpl::SurfaceObserverImpl()
++    : m_listener(nullptr)
++    , m_framesPosted(false)
++{
++    m_cursorNameToShape["left_ptr"] = Qt::ArrowCursor;
++    m_cursorNameToShape["up_arrow"] = Qt::UpArrowCursor;
++    m_cursorNameToShape["cross"] = Qt::CrossCursor;
++    m_cursorNameToShape["watch"] = Qt::WaitCursor;
++    m_cursorNameToShape["xterm"] = Qt::IBeamCursor;
++    m_cursorNameToShape["size_ver"] = Qt::SizeVerCursor;
++    m_cursorNameToShape["size_hor"] = Qt::SizeHorCursor;
++    m_cursorNameToShape["size_bdiag"] = Qt::SizeBDiagCursor;
++    m_cursorNameToShape["size_fdiag"] = Qt::SizeFDiagCursor;
++    m_cursorNameToShape["size_all"] = Qt::SizeAllCursor;
++    m_cursorNameToShape["blank"] = Qt::BlankCursor;
++    m_cursorNameToShape["split_v"] = Qt::SplitVCursor;
++    m_cursorNameToShape["split_h"] = Qt::SplitHCursor;
++    m_cursorNameToShape["hand"] = Qt::PointingHandCursor;
++    m_cursorNameToShape["forbidden"] = Qt::ForbiddenCursor;
++    m_cursorNameToShape["whats_this"] = Qt::WhatsThisCursor;
++    m_cursorNameToShape["left_ptr_watch"] = Qt::BusyCursor;
++    m_cursorNameToShape["openhand"] = Qt::OpenHandCursor;
++    m_cursorNameToShape["closedhand"] = Qt::ClosedHandCursor;
++    m_cursorNameToShape["dnd-copy"] = Qt::DragCopyCursor;
++    m_cursorNameToShape["dnd-move"] = Qt::DragMoveCursor;
++    m_cursorNameToShape["dnd-link"] = Qt::DragLinkCursor;
++
++    // Used by Mir client API (mir_*_cursor_name strings)
++    m_cursorNameToShape["default"] = Qt::ArrowCursor;
++    m_cursorNameToShape["disabled"] = Qt::BlankCursor;
++    m_cursorNameToShape["arrow"] = Qt::ArrowCursor;
++    m_cursorNameToShape["busy"] = Qt::WaitCursor;
++    m_cursorNameToShape["caret"] = Qt::IBeamCursor;
++    m_cursorNameToShape["pointing-hand"] = Qt::PointingHandCursor;
++    m_cursorNameToShape["open-hand"] = Qt::OpenHandCursor;
++    m_cursorNameToShape["closed-hand"] = Qt::ClosedHandCursor;
++    m_cursorNameToShape["horizontal-resize"] = Qt::SizeHorCursor;
++    m_cursorNameToShape["vertical-resize"] = Qt::SizeVerCursor;
++    m_cursorNameToShape["diagonal-resize-bottom-to-top"] = Qt::SizeBDiagCursor;
++    m_cursorNameToShape["diagonal-resize-top_to_bottom"] = Qt::SizeFDiagCursor; // current string with typo
++    m_cursorNameToShape["diagonal-resize-top-to-bottom"] = Qt::SizeFDiagCursor; // how it will be when they fix it (if ever)
++    m_cursorNameToShape["omnidirectional-resize"] = Qt::SizeAllCursor;
++    m_cursorNameToShape["vsplit-resize"] = Qt::SplitVCursor;
++    m_cursorNameToShape["hsplit-resize"] = Qt::SplitHCursor;
++    m_cursorNameToShape["crosshair"] = Qt::CrossCursor;
++
++    qRegisterMetaType<MirShellChrome>("MirShellChrome");
++}
++
++MirSurface::SurfaceObserverImpl::~SurfaceObserverImpl()
++{
++}
++
++void MirSurface::SurfaceObserverImpl::setListener(QObject *listener)
++{
++    m_listener = listener;
++    if (m_framesPosted) {
++        Q_EMIT framesPosted();
++    }
++}
++
++void MirSurface::SurfaceObserverImpl::frame_posted(int /*frames_available*/, mir::geometry::Size const& /*size*/)
++{
++    m_framesPosted = true;
++    if (m_listener) {
++        Q_EMIT framesPosted();
++    }
++}
++
++void MirSurface::SurfaceObserverImpl::renamed(char const * name)
++{
++    Q_EMIT nameChanged(QString::fromUtf8(name));
++}
++
++void MirSurface::SurfaceObserverImpl::cursor_image_removed()
++{
++    Q_EMIT cursorChanged(QCursor());
++}
++
++#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 25, 0)
++void MirSurface::SurfaceObserverImpl::placed_relative(mir::geometry::Rectangle const& /*placement*/)
++{
++}
++#endif
++
++void MirSurface::SurfaceObserverImpl::attrib_changed(MirSurfaceAttrib attribute, int value)
++{
++    if (m_listener) {
++        Q_EMIT attributeChanged(attribute, value);
++    }
++}
++
++void MirSurface::SurfaceObserverImpl::resized_to(mir::geometry::Size const&size)
++{
++    Q_EMIT resized(QSize(size.width.as_int(), size.height.as_int()));
++}
++
++void MirSurface::SurfaceObserverImpl::cursor_image_set_to(const mir::graphics::CursorImage &cursorImage)
++{
++    QCursor qcursor = createQCursorFromMirCursorImage(cursorImage);
++    Q_EMIT cursorChanged(qcursor);
++}
++
++void MirSurface::SurfaceObserverImpl::keymap_changed(MirInputDeviceId, const std::string &, const std::string &layout,
++                                                     const std::string &variant, const std::string &)
++{
++    Q_EMIT keymapChanged(QString::fromStdString(layout), QString::fromStdString(variant));
++}
++
++QCursor MirSurface::SurfaceObserverImpl::createQCursorFromMirCursorImage(const mir::graphics::CursorImage &cursorImage) {
++    if (cursorImage.as_argb_8888() == nullptr) {
++        // Must be a named cursor
++        auto namedCursor = dynamic_cast<const qtmir::NamedCursor*>(&cursorImage);
++        Q_ASSERT(namedCursor != nullptr);
++        if (namedCursor) {
++            // NB: If we need a named cursor not covered by Qt::CursorShape, we won't be able to
++            //     used Qt's cursor API anymore for transmitting MirSurface's cursor image.
++
++            Qt::CursorShape cursorShape = Qt::ArrowCursor;
++            {
++                auto iterator = m_cursorNameToShape.constFind(namedCursor->name());
++                if (iterator == m_cursorNameToShape.constEnd()) {
++                    qCWarning(QTMIR_SURFACES).nospace() << "SurfaceObserver: unrecognized cursor name "
++                                                        << namedCursor->name();
++                } else {
++                    cursorShape = iterator.value();
++                }
++            }
++            return QCursor(cursorShape);
++        } else {
++            // shouldn't happen
++            return QCursor();
++        }
++    } else {
++        QImage image((const uchar*)cursorImage.as_argb_8888(),
++                     cursorImage.size().width.as_int(), cursorImage.size().height.as_int(), QImage::Format_ARGB32);
++
++        return QCursor(QPixmap::fromImage(image), cursorImage.hotspot().dx.as_int(), cursorImage.hotspot().dy.as_int());
++    }
++}
++
++void MirSurface::requestFocus()
++{
++    DEBUG_MSG << "()";
++    Q_EMIT focusRequested();
++}
 === modified file 'src/modules/Unity/Application/mirsurface.h'
 --- src/modules/Unity/Application/mirsurface.h	2016-10-11 20:50:50 +0000
 +++ src/modules/Unity/Application/mirsurface.h	2016-12-16 08:22:54 +0000
@@ -22,45 +22,37 @@
  // Qt
  #include <QCursor>
--#include <QElapsedTimer>
  #include <QMutex>
  #include <QPointer>
  #include <QRect>
  #include <QSharedPointer>
  #include <QWeakPointer>
  #include <QSet>
++#include <QTimer>
  #include "mirbuffersgtexture.h"
--#include "session.h"
--
--// mirserver
--#include "creationhints.h"
++#include "windowcontrollerinterface.h"
++#include "windowmodelnotifier.h"
  // mir
  #include <mir_toolkit/common.h>
--namespace mir {
--namespace shell { class Shell; }
--namespace scene {class Surface; }
--}
  class SurfaceObserver;
  namespace qtmir {
  class AbstractTimer;
++class SessionInterface;
  class MirSurface : public MirSurfaceInterface
+ {
      Q_OBJECT
  public:
--    MirSurface(std::shared_ptr<mir::scene::Surface> surface,
--            const QString& persistentId,
--            SessionInterface* session,
--            mir::shell::Shell *shell,
--            std::shared_ptr<SurfaceObserver> observer,
--            const CreationHints &);
++    MirSurface(NewWindow windowInfo,
++               WindowControllerInterface *controller,
++               SessionInterface *session = nullptr);
      virtual ~MirSurface();
      ////
@@ -74,10 +66,14 @@
      QSize size() const override;
      void resize(int width, int height) override;
--    void resize(const QSize &size) override { resize(size.width(), size.height()); }
++    Q_INVOKABLE void resize(const QSize &size) override { resize(size.width(), size.height()); }
++
++    QPoint position() const override;
++
++    QPoint requestedPosition() const override;
++    void setRequestedPosition(const QPoint &) override;
      Mir::State state() const override;
--    void setState(Mir::State qmlState) override;
      bool live() const override;
@@ -98,16 +94,15 @@
      bool confinesMousePointer() const override;
--    Q_INVOKABLE void requestFocus() override;
++    Q_INVOKABLE void activate() override;
      Q_INVOKABLE void close() override;
--    Q_INVOKABLE void raise() override;
      ////
      // qtmir::MirSurfaceInterface
      void setLive(bool value) override;
--    bool isFirstFrameDrawn() const override { return m_firstFrameDrawn; }
++    bool isReady() const override { return m_ready; }
      void stopFrameDropper() override;
      void startFrameDropper() override;
@@ -116,7 +111,7 @@
      void registerView(qintptr viewId) override;
      void unregisterView(qintptr viewId) override;
--    void setViewVisibility(qintptr viewId, bool visible) override;
++    void setViewExposure(qintptr viewId, bool exposed) override;
      // methods called from the rendering (scene graph) thread:
      QSharedPointer<QSGTexture> texture() override;
@@ -156,27 +151,31 @@
      Mir::ShellChrome shellChrome() const override;
--    void setScreen(QScreen *screen) override;
--
      SessionInterface* session() override { return m_session.data(); }
      bool inputAreaContains(const QPoint &) const override;
++    void requestFocus() override;
++
      ////
      // Own API
++    void setPosition(const QPoint newPosition);
++    void updateState(Mir::State state);
++    void setReady();
++    miral::Window window() const { return m_window; }
      // useful for tests
      void setCloseTimer(AbstractTimer *timer);
++    std::shared_ptr<SurfaceObserver> surfaceObserver() const;
  public Q_SLOTS:
++    ////
++    // unity::shell::application::MirSurfaceInterface
++    void requestState(Mir::State qmlState) override;
++
++    ////
++    // qtmir::MirSurfaceInterface
      void onCompositorSwappedBuffers() override;
--
--    void setMinimumWidth(int) override;
--    void setMinimumHeight(int) override;
--    void setMaximumWidth(int) override;
--    void setMaximumHeight(int) override;
--    void setWidthIncrement(int) override;
--    void setHeightIncrement(int) override;
      void setShellChrome(Mir::ShellChrome shellChrome) override;
  private Q_SLOTS:
@@ -192,15 +191,32 @@
  private:
      void syncSurfaceSizeWithItemSize();
      bool clientIsRunning() const;
--    void updateVisibility();
++    void updateExposure();
      void applyKeymap();
      void updateActiveFocus();
--
--    std::shared_ptr<mir::scene::Surface> m_surface;
++    void updateVisible();
++    void onNameChanged(const QString &name);
++    void onMinimumWidthChanged(int minWidth);
++    void onMinimumHeightChanged(int minHeight);
++    void onMaximumWidthChanged(int maxWidth);
++    void onMaximumHeightChanged(int maxHeight);
++    void onWidthIncrementChanged(int incWidth);
++    void onHeightIncrementChanged(int incHeight);
++
++    const miral::Window m_window;
++    const std::shared_ptr<ExtraWindowInfo> m_extraInfo;
++    QString m_name;
++    MirSurfaceType m_type;
++    int m_minWidth;
++    int m_minHeight;
++    int m_maxWidth;
++    int m_maxHeight;
++    int m_incWidth;
++    int m_incHeight;
++
++    const std::shared_ptr<mir::scene::Surface> m_surface; // keep copy of the Surface for lifecycle
      QPointer<SessionInterface> m_session;
--    mir::shell::Shell *const m_shell;
--    QString m_persistentId;
--    bool m_firstFrameDrawn;
++    WindowControllerInterface *const m_controller;
      //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
      Mir::OrientationAngle m_orientationAngle;
@@ -214,31 +230,30 @@
      bool m_textureUpdated;
      unsigned int m_currentFrameNumber;
++    bool m_ready{false};
++    bool m_visible;
      bool m_live;
      struct View {
--        bool visible;
++        bool exposed;
      };
      QHash<qintptr, View> m_views;
      QSet<qintptr> m_activelyFocusedViews;
      bool m_neverSetSurfaceFocus{true};
--    std::shared_ptr<SurfaceObserver> m_surfaceObserver;
++    class SurfaceObserverImpl;
++    std::shared_ptr<SurfaceObserverImpl> m_surfaceObserver;
++    QPoint m_position;
++    QPoint m_requestedPosition;
      QSize m_size;
++    QSize m_pendingResize;
      QString m_keymap;
      QCursor m_cursor;
++    Mir::State m_state; // FIXME: remove when Mir gains additional window states to match Mir::State
      Mir::ShellChrome m_shellChrome;
--    int m_minimumWidth{0};
--    int m_minimumHeight{0};
--    int m_maximumWidth{0};
--    int m_maximumHeight{0};
--    int m_widthIncrement{0};
--    int m_heightIncrement{0};
--    QSize m_pendingResize;
--
      QRect m_inputBounds;
      bool m_focused{false};
@@ -250,11 +265,6 @@
      };
      ClosingState m_closingState{NotClosing};
      AbstractTimer *m_closeTimer{nullptr};
--
--    // TODO: Make it configurable, exposing it as a QML property to shell.
--    // In milliseconds.
--    const int m_minimumAgeForOcclusion{10000};
--    bool m_oldEnoughToBeOccluded{false};
  };
  } // namespace qtmir
 === modified file 'src/modules/Unity/Application/mirsurfaceinterface.h'
 --- src/modules/Unity/Application/mirsurfaceinterface.h	2016-07-05 12:41:04 +0000
 +++ src/modules/Unity/Application/mirsurfaceinterface.h	2016-12-16 08:22:54 +0000
@@ -24,6 +24,7 @@
  // Qt
  #include <QCursor>
++#include <QPoint>
  #include <QSharedPointer>
  #include <QTouchEvent>
@@ -44,7 +45,7 @@
      virtual void setLive(bool value) = 0;
--    virtual bool isFirstFrameDrawn() const = 0;
++    virtual bool isReady() const = 0;
      virtual void stopFrameDropper() = 0;
      virtual void startFrameDropper() = 0;
@@ -53,7 +54,7 @@
      virtual void registerView(qintptr viewId) = 0;
      virtual void unregisterView(qintptr viewId) = 0;
--    virtual void setViewVisibility(qintptr viewId, bool visible) = 0;
++    virtual void setViewExposure(qintptr viewId, bool exposed) = 0;
      // methods called from the rendering (scene graph) thread:
      virtual QSharedPointer<QSGTexture> texture() = 0;
@@ -102,28 +103,21 @@
      virtual QCursor cursor() const = 0;
--    virtual void setScreen(QScreen *screen) = 0;
--
      virtual SessionInterface* session() = 0;
      virtual bool inputAreaContains(const QPoint &) const = 0;
++    virtual void requestFocus() = 0;
++
  public Q_SLOTS:
      virtual void onCompositorSwappedBuffers() = 0;
--    virtual void setMinimumWidth(int) = 0;
--    virtual void setMinimumHeight(int) = 0;
--    virtual void setMaximumWidth(int) = 0;
--    virtual void setMaximumHeight(int) = 0;
--    virtual void setWidthIncrement(int) = 0;
--    virtual void setHeightIncrement(int) = 0;
      virtual void setShellChrome(Mir::ShellChrome shellChrome) = 0;
  Q_SIGNALS:
++    void ready();
      void cursorChanged(const QCursor &cursor);
      void raiseRequested();
--    void closeRequested();
--    void firstFrameDrawn();
      void framesPosted();
      void isBeingDisplayedChanged();
      void frameDropped();
 === modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
 --- src/modules/Unity/Application/mirsurfaceitem.cpp	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/mirsurfaceitem.cpp	2016-12-16 08:22:54 +0000
@@ -18,7 +18,6 @@
  #include "application.h"
  #include "session.h"
  #include "mirsurfaceitem.h"
--#include "mirfocuscontroller.h"
  #include "logging.h"
  #include "tracepoints.h" // generated from tracepoints.tp
  #include "timestamp.h"
@@ -104,18 +103,10 @@
      connect(&m_updateMirSurfaceSizeTimer, &QTimer::timeout, this, &MirSurfaceItem::updateMirSurfaceSize);
      connect(this, &QQuickItem::activeFocusChanged, this, &MirSurfaceItem::updateMirSurfaceActiveFocus);
--    connect(this, &QQuickItem::visibleChanged, this, &MirSurfaceItem::updateMirSurfaceVisibility);
++    connect(this, &QQuickItem::visibleChanged, this, &MirSurfaceItem::updateMirSurfaceExposure);
      connect(this, &QQuickItem::windowChanged, this, &MirSurfaceItem::onWindowChanged);
+ }
--void MirSurfaceItem::componentComplete()
--{
--    QQuickItem::componentComplete();
--    if (window()) {
--        updateScreen(window()->screen());
--    }
--}
--
  MirSurfaceItem::~MirSurfaceItem()
+ {
      qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::~MirSurfaceItem - this=" << this;
@@ -492,13 +483,6 @@
+     }
+ }
--void MirSurfaceItem::setSurfaceState(Mir::State state)
--{
--    if (m_surface) {
--        m_surface->setState(state);
--    }
--}
--
  void MirSurfaceItem::scheduleMirSurfaceSizeUpdate()
+ {
      if (!m_updateMirSurfaceSizeTimer.isActive()) {
@@ -519,13 +503,13 @@
      m_surface->resize(width, height);
+ }
--void MirSurfaceItem::updateMirSurfaceVisibility()
++void MirSurfaceItem::updateMirSurfaceExposure()
+ {
      if (!m_surface || !m_surface->live()) {
          return;
+     }
--    m_surface->setViewVisibility((qintptr)this, isVisible());
++    m_surface->setViewExposure((qintptr)this, isVisible());
+ }
  void MirSurfaceItem::updateMirSurfaceActiveFocus()
@@ -628,10 +612,7 @@
          updateMirSurfaceSize();
          setImplicitSize(m_surface->size().width(), m_surface->size().height());
--        updateMirSurfaceVisibility();
--        if (window()) {
--            updateScreen(window()->screen());
--        }
++        updateMirSurfaceExposure();
          // Qt::ArrowCursor is the default when no cursor has been explicitly set, so no point forwarding it.
          if (m_surface->cursor().shape() != Qt::ArrowCursor) {
@@ -672,16 +653,6 @@
      if (m_window) {
          connect(m_window, &QQuickWindow::frameSwapped, this, &MirSurfaceItem::onCompositorSwappedBuffers,
                  Qt::DirectConnection);
--
--        updateScreen(m_window->screen());
--        connect(m_window, &QQuickWindow::screenChanged, this, &MirSurfaceItem::updateScreen);
--    }
--}
--
--void MirSurfaceItem::updateScreen(QScreen *screen)
--{
--    if (screen && m_surface) {
--        m_surface->setScreen(screen);
+     }
+ }
 === modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
 --- src/modules/Unity/Application/mirsurfaceitem.h	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/mirsurfaceitem.h	2016-12-16 08:22:54 +0000
@@ -31,7 +31,6 @@
  namespace qtmir {
--class MirSurfaceManager;
  class QSGMirSurfaceNode;
  class MirTextureProvider;
@@ -52,7 +51,6 @@
      Mir::ShellChrome shellChrome() const override;
      Mir::State surfaceState() const override;
--    void setSurfaceState(Mir::State) override;
      Mir::OrientationAngle orientationAngle() const override;
      void setOrientationAngle(Mir::OrientationAngle angle) override;
@@ -109,7 +107,6 @@
      QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) override;
--    void componentComplete() override;
      void releaseResources() override;
  private Q_SLOTS:
@@ -117,13 +114,12 @@
      void updateMirSurfaceSize();
      void updateMirSurfaceActiveFocus();
--    void updateMirSurfaceVisibility();
++    void updateMirSurfaceExposure();
      void onActualSurfaceSizeChanged(QSize size);
      void onCompositorSwappedBuffers();
      void onWindowChanged(QQuickWindow *window);
--    void updateScreen(QScreen *screen);
  private:
      void ensureTextureProvider();
 === modified file 'src/modules/Unity/Application/mirsurfacelistmodel.cpp'
 --- src/modules/Unity/Application/mirsurfacelistmodel.cpp	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/mirsurfacelistmodel.cpp	2016-12-16 08:22:54 +0000
@@ -77,7 +77,11 @@
  void MirSurfaceListModel::connectSurface(MirSurfaceInterface *surface)
+ {
--    connect(surface, &MirSurfaceInterface::raiseRequested, this, [this, surface](){ this->raise(surface); });
++    connect(surface, &MirSurfaceInterface::focusedChanged, this, [this, surface](bool focused){
++        if (focused) {
++            this->raise(surface);
++        }
++    });
      connect(surface, &QObject::destroyed, this, [this, surface](){ this->removeSurface(surface); });
+ }
@@ -143,10 +147,12 @@
      for (int i = prependLast; i >= prependFirst; --i) {
          auto surface = surfaceList[i];
          m_surfaceList.prepend(surface);
--        connect(surface, &MirSurfaceInterface::raiseRequested, this,
--                [this, surface]()
++        connect(surface, &MirSurfaceInterface::focusedChanged, this,
++                [this, surface](bool focused)
+                 {
--                    this->raise(surface);
++                    if (focused) {
++                        this->raise(surface);
++                    }
                  });
+     }
      endInsertRows();
 === removed file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
 --- src/modules/Unity/Application/mirsurfacemanager.cpp	2016-08-30 12:24:51 +0000
 +++ src/modules/Unity/Application/mirsurfacemanager.cpp	1970-01-01 00:00:00 +0000
@@ -1,188 +0,0 @@
--/*
-- * Copyright (C) 2013-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 "mirsurfacemanager.h"
--
--// Qt
--#include <QGuiApplication>
--#include <QMutexLocker>
--
--// local
--#include "mirsurface.h"
--#include "sessionmanager.h"
--#include "application_manager.h"
--#include "tracepoints.h" // generated from tracepoints.tp
--
--// common
--#include <debughelpers.h>
--
--// QPA mirserver
--#include "nativeinterface.h"
--#include "sessionlistener.h"
--#include "logging.h"
--#include "creationhints.h"
--#include "mirserver.h"
--
--// mir
--#include <mir/scene/surface.h>
--#include <mir/shell/persistent_surface_store.h>
--
--
--namespace ms = mir::scene;
--namespace msh = mir::shell;
--
--namespace qtmir {
--
--MirSurfaceManager *MirSurfaceManager::instance = nullptr;
--
--
--void connectToSessionListener(MirSurfaceManager *manager, SessionListener *listener)
--{
--    QObject::connect(listener, &SessionListener::sessionCreatedSurface,
--                     manager, &MirSurfaceManager::onSessionCreatedSurface);
--    QObject::connect(listener, &SessionListener::sessionDestroyingSurface,
--                     manager, &MirSurfaceManager::onSessionDestroyingSurface);
--}
--
--MirSurfaceManager* MirSurfaceManager::singleton()
--{
--    if (!instance) {
--
--        NativeInterface *nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
--
--        if (!nativeInterface) {
--            qCritical("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
--            QGuiApplication::quit();
--            return nullptr;
--        }
--
--        SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
--        mir::shell::Shell *shell = static_cast<mir::shell::Shell*>(nativeInterface->nativeResourceForIntegration("Shell"));
--
--
--        instance = new MirSurfaceManager(shell,
--                                         SessionManager::singleton(),
--                                         nativeInterface->thePersistentSurfaceStore());
--
--        connectToSessionListener(instance, sessionListener);
--    }
--    return instance;
--}
--
--MirSurfaceManager::MirSurfaceManager(
--        mir::shell::Shell* shell,
--        SessionManager* sessionManager,
--        std::shared_ptr<msh::PersistentSurfaceStore> surfaceStore,
--        QObject* parent)
--    : QObject(parent)
--    , m_shell(shell)
--    , m_sessionManager(sessionManager)
--    , m_surfaceStore(surfaceStore)
--{
--    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::MirSurfaceManager - this=" << this;
--    setObjectName(QStringLiteral("qtmir::SurfaceManager"));
--}
--
--MirSurfaceManager::~MirSurfaceManager()
--{
--    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::~MirSurfaceManager - this=" << this;
--
--    m_mirSurfaceToQmlSurfaceHash.clear();
--}
--
--void MirSurfaceManager::onSessionCreatedSurface(const mir::scene::Session *mirSession,
--                                                const std::shared_ptr<mir::scene::Surface> &surface,
--                                                const std::shared_ptr<SurfaceObserver> &observer,
--                                                const qtmir::CreationHints &creationHints)
--{
--    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionCreatedSurface - mirSession=" << mirSession
--                            << "surface=" << surface.get() << "surface.name=" << surface->name().c_str()
--                            << "creationHints=" << creationHints.toString();
--
--    SessionInterface* session = m_sessionManager->findSession(mirSession);
--    auto qmlSurface = new MirSurface(surface,
--                                     QString::fromStdString(m_surfaceStore->id_for_surface(surface).serialize_to_string()),
--                                     session,
--                                     m_shell,
--                                     observer,
--                                     creationHints);
--    {
--        QMutexLocker lock(&m_mutex);
--        m_mirSurfaceToQmlSurfaceHash.insert(surface.get(), qmlSurface);
--    }
--
--    if (session)
--        session->registerSurface(qmlSurface);
--
--    if (qmlSurface->type() == Mir::InputMethodType) {
--        m_inputMethodSurface = qmlSurface;
--        Q_EMIT inputMethodSurfaceChanged();
--    }
--
--    // Only notify QML of surface creation once it has drawn its first frame.
--    connect(qmlSurface, &MirSurfaceInterface::firstFrameDrawn, this, [=]() {
--        tracepoint(qtmir, firstFrameDrawn);
--        Q_EMIT surfaceCreated(qmlSurface);
--    });
--
--    // clean up after MirSurface is destroyed
--    connect(qmlSurface, &QObject::destroyed, this, [&](QObject *obj) {
--        auto qmlSurface = static_cast<MirSurfaceInterface*>(obj);
--        {
--            QMutexLocker lock(&m_mutex);
--            m_mirSurfaceToQmlSurfaceHash.remove(m_mirSurfaceToQmlSurfaceHash.key(qmlSurface));
--        }
--
--        tracepoint(qtmir, surfaceDestroyed);
--    });
--    tracepoint(qtmir, surfaceCreated);
--}
--
--void MirSurfaceManager::onSessionDestroyingSurface(const mir::scene::Session *session,
--                                                   const std::shared_ptr<mir::scene::Surface> &surface)
--{
--    qCDebug(QTMIR_SURFACES) << "MirSurfaceManager::onSessionDestroyingSurface - session=" << session
--                            << "surface=" << surface.get() << "surface.name=" << surface->name().c_str();
--
--    MirSurfaceInterface* qmlSurface = nullptr;
--    {
--        QMutexLocker lock(&m_mutex);
--        auto it = m_mirSurfaceToQmlSurfaceHash.find(surface.get());
--        if (it != m_mirSurfaceToQmlSurfaceHash.end()) {
--            qmlSurface = it.value();
--            m_mirSurfaceToQmlSurfaceHash.erase(it);
--        } else {
--            qCritical() << "MirSurfaceManager::onSessionDestroyingSurface: unable to find MirSurface corresponding"
--                        << "to surface=" << surface.get() << "surface.name=" << surface->name().c_str();
--            return;
--        }
--    }
--
--    if (qmlSurface->type() == Mir::InputMethodType) {
--        m_inputMethodSurface = nullptr;
--        Q_EMIT inputMethodSurfaceChanged();
--    }
--
--    qmlSurface->setLive(false);
--    Q_EMIT surfaceDestroyed(qmlSurface);
--}
--
--MirSurfaceInterface* MirSurfaceManager::inputMethodSurface() const
--{
--    return m_inputMethodSurface;
--}
--
--} // namespace qtmir
 === removed file 'src/modules/Unity/Application/mirsurfacemanager.h'
 --- src/modules/Unity/Application/mirsurfacemanager.h	2016-08-30 12:24:19 +0000
 +++ src/modules/Unity/Application/mirsurfacemanager.h	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
--/*
-- * Copyright (C) 2013-2015 Canonical, Ltd.
-- *
-- * This program is free software: you can redistribute it and/or modify it under
-- * the terms of the GNU 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 MIR_SURFACE_MANAGER_H
--#define MIR_SURFACE_MANAGER_H
--
--// std
--#include <memory>
--
--// Qt
--#include <QObject>
--#include <QHash>
--#include <QMutex>
--#include <QSharedPointer>
--
--// Mir
--#include <mir_toolkit/common.h>
--
--// mirserver qpa
--#include <creationhints.h>
--
--namespace mir {
--    namespace scene {
--        class Surface;
--        class Session;
--        class PromptSession;
--    }
--    namespace shell {
--        class Shell;
--        class PersistentSurfaceStore;
--    }
--}
--
--class SurfaceObserver;
--
--namespace qtmir {
--
--class Application;
--class ApplicationManager;
--class MirSurfaceInterface;
--class SessionManager;
--
--class MirSurfaceManager : public QObject
--{
--    Q_OBJECT
--    Q_PROPERTY(MirSurfaceInterface* inputMethodSurface READ inputMethodSurface NOTIFY inputMethodSurfaceChanged)
--public:
--    explicit MirSurfaceManager(
--        mir::shell::Shell* shell,
--        SessionManager* sessionManager,
--        std::shared_ptr<mir::shell::PersistentSurfaceStore> surfaceStore,
--        QObject* parent = nullptr
--    );
--    ~MirSurfaceManager();
--
--    static MirSurfaceManager* singleton();
--
--    MirSurfaceInterface* inputMethodSurface() const;
--
--Q_SIGNALS:
--    void inputMethodSurfaceChanged();
--    void surfaceCreated(MirSurfaceInterface* surface);
--    void surfaceDestroyed(MirSurfaceInterface* surface);
--
--public Q_SLOTS:
--    void onSessionCreatedSurface(const mir::scene::Session *,
--                                 const std::shared_ptr<mir::scene::Surface> &,
--                                 std::shared_ptr<SurfaceObserver> const&,
--                                 const qtmir::CreationHints &);
--    void onSessionDestroyingSurface(const mir::scene::Session *, const std::shared_ptr<mir::scene::Surface> &);
--
--protected:
--    QHash<const mir::scene::Surface *, MirSurfaceInterface *> m_mirSurfaceToQmlSurfaceHash;
--    QMutex m_mutex;
--
--private:
--    mir::shell::Shell *const m_shell;
--    SessionManager* m_sessionManager;
--    std::shared_ptr<mir::shell::PersistentSurfaceStore> m_surfaceStore;
--    static MirSurfaceManager *instance;
--    MirSurfaceInterface* m_inputMethodSurface = nullptr;
--};
--
--} // namespace qtmir
--
--#endif // MIR_SURFACE_MANAGER_H
 === modified file 'src/modules/Unity/Application/plugin.cpp'
 --- src/modules/Unity/Application/plugin.cpp	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/plugin.cpp	2016-12-16 08:22:54 +0000
@@ -20,11 +20,11 @@
  // local
  #include "application.h"
  #include "application_manager.h"
--#include "mirfocuscontroller.h"
--#include "mirsurfacemanager.h"
  #include "mirsurfaceinterface.h"
  #include "mirsurfaceitem.h"
  #include "mirsurfacelistmodel.h"
++#include "windowmodel.h"
++#include "surfacemanager.h"
  // platforms/mirserver
  #include <mirsingleton.h>
@@ -46,22 +46,9 @@
      return qtmir::ApplicationManager::singleton();
+ }
--QObject* surfaceManagerSingleton(QQmlEngine* engine, QJSEngine* scriptEngine) {
--    Q_UNUSED(engine);
--    Q_UNUSED(scriptEngine);
--    qCDebug(QTMIR_APPLICATIONS) << "surfaceManagerSingleton - engine=" << engine << "scriptEngine=" << scriptEngine;
--
--    return qtmir::MirSurfaceManager::singleton();
--}
--
  QObject* mirSingleton(QQmlEngine* /*engine*/, QJSEngine* /*scriptEngine*/) {
      return qtmir::Mir::instance();
+ }
--
--QObject* mirFocusControllerSingleton(QQmlEngine*, QJSEngine*)
--{
--    return MirFocusController::instance();
--}
  } // anonymous namespace
  class UnityApplicationPlugin : public QQmlExtensionPlugin {
@@ -77,6 +64,7 @@
          qRegisterMetaType<qtmir::Application*>("Application*");
          qRegisterMetaType<unity::shell::application::MirSurfaceInterface*>("MirSurfaceInterface*");
          qRegisterMetaType<unity::shell::application::MirSurfaceListInterface*>("unity::shell::application::MirSurfaceListInterface*");
++        qRegisterMetaType<unity::shell::application::SurfaceManagerInterface*>("unity::shell::application::SurfaceManagerInterface*");
          qRegisterMetaType<MirSurfaceAttrib>("MirSurfaceAttrib");
          qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
@@ -87,13 +75,13 @@
                      uri, 0, 1, "ApplicationInfoInterface", "Abstract interface. Cannot be created in QML");
          qmlRegisterUncreatableType<qtmir::Application>(
                      uri, 0, 1, "ApplicationInfo", "Application can't be instantiated");
--        qmlRegisterSingletonType<qtmir::MirSurfaceManager>(
--                    uri, 0, 1, "SurfaceManager", surfaceManagerSingleton);
--        qmlRegisterSingletonType<MirFocusController>(uri, 0, 1, "MirFocusController", mirFocusControllerSingleton);
          qmlRegisterUncreatableType<unity::shell::application::MirSurfaceInterface>(
                      uri, 0, 1, "MirSurface", "MirSurface can't be instantiated from QML");
          qmlRegisterType<qtmir::MirSurfaceItem>(uri, 0, 1, "MirSurfaceItem");
          qmlRegisterSingletonType<qtmir::Mir>(uri, 0, 1, "Mir", mirSingleton);
++        qmlRegisterType<qtmir::SurfaceManager>(uri, 0, 1, "SurfaceManager");
++
++        qmlRegisterType<qtmir::WindowModel>(uri, 0, 1, "WindowModel");
+     }
      virtual void initializeEngine(QQmlEngine *engine, const char *uri)
 === modified file 'src/modules/Unity/Application/session.cpp'
 --- src/modules/Unity/Application/session.cpp	2016-09-22 15:58:26 +0000
 +++ src/modules/Unity/Application/session.cpp	2016-12-16 08:22:54 +0000
@@ -19,16 +19,14 @@
  #include "debughelpers.h"
  #include "session.h"
  #include "mirsurfaceinterface.h"
--#include "mirsurfacemanager.h"
  #include "mirsurfaceitem.h"
++#include "promptsession.h"
  // mirserver
  #include "logging.h"
--// mir
--#include <mir/scene/session.h>
--#include <mir/scene/prompt_session.h>
--#include <mir/scene/prompt_session_manager.h>
++// miral
++#include <miral/application.h>
  // Qt
  #include <QPainter>
@@ -66,7 +64,7 @@
+ }
  Session::Session(const std::shared_ptr<ms::Session>& session,
--                 const std::shared_ptr<ms::PromptSessionManager>& promptSessionManager,
++                 const std::shared_ptr<PromptSessionManager>& promptSessionManager,
                   QObject *parent)
      : SessionInterface(parent)
      , m_session(session)
@@ -121,7 +119,7 @@
  QString Session::name() const
+ {
--    return QString::fromStdString(m_session->name());
++    return QString::fromStdString(miral::name_of(m_session));
+ }
  std::shared_ptr<ms::Session> Session::session() const
@@ -202,10 +200,10 @@
      DEBUG_MSG << "(surface=" << newSurface << ")";
      // Only notify QML of surface creation once it has drawn its first frame.
--    if (newSurface->isFirstFrameDrawn()) {
++    if (newSurface->isReady()) {
          prependSurface(newSurface);
      } else {
--        connect(newSurface, &MirSurfaceInterface::firstFrameDrawn, this, [this, newSurface]()
++        connect(newSurface, &MirSurfaceInterface::ready, this, [this, newSurface]()
+             {
                  newSurface->disconnect(this);
                  this->prependSurface(newSurface);
@@ -234,6 +232,10 @@
              this->removeSurface(newSurface);
          });
      connect(newSurface, &MirSurfaceInterface::focusRequested, this, &SessionInterface::focusRequested);
++    connect(newSurface, &MirSurfaceInterface::focusedChanged, this, [&](bool /*value*/) {
++        // TODO: May want to optimize that in the future.
++        Q_EMIT focusedChanged(focused());
++    });
      m_surfaceList.prependSurface(newSurface);
      m_hadSurface = true;
@@ -289,11 +291,11 @@
+ {
      DEBUG_MSG << " state=" << sessionStateToString(m_state);
      if (m_state == Running) {
--        session()->set_lifecycle_state(mir_lifecycle_state_will_suspend);
++        miral::apply_lifecycle_state_to(session(), mir_lifecycle_state_will_suspend);
          m_suspendTimer->start();
--        foreachPromptSession([this](const std::shared_ptr<ms::PromptSession>& promptSession) {
--            m_promptSessionManager->suspend_prompt_session(promptSession);
++        foreachPromptSession([this](const qtmir::PromptSession &promptSession) {
++            m_promptSessionManager->suspendPromptSession(promptSession);
          });
          foreachChildSession([](SessionInterface* session) {
@@ -322,10 +324,10 @@
+         }
+     }
--    session()->set_lifecycle_state(mir_lifecycle_state_resumed);
++    miral::apply_lifecycle_state_to(session(), mir_lifecycle_state_resumed);
--    foreachPromptSession([this](const std::shared_ptr<ms::PromptSession>& promptSession) {
--        m_promptSessionManager->resume_prompt_session(promptSession);
++    foreachPromptSession([this](const qtmir::PromptSession &promptSession) {
++        m_promptSessionManager->resumePromptSession(promptSession);
      });
      foreachChildSession([](SessionInterface* session) {
@@ -453,16 +455,16 @@
      return m_children;
+ }
--void Session::appendPromptSession(const std::shared_ptr<ms::PromptSession>& promptSession)
++void Session::appendPromptSession(const qtmir::PromptSession &promptSession)
+ {
--    DEBUG_MSG << "(promptSession=" << (promptSession ? promptSession.get() : nullptr) << ")";
++    DEBUG_MSG << "(promptSession=" << promptSession.get() << ")";
      m_promptSessions.append(promptSession);
+ }
--void Session::removePromptSession(const std::shared_ptr<ms::PromptSession>& promptSession)
++void Session::removePromptSession(const qtmir::PromptSession &promptSession)
+ {
--    DEBUG_MSG << "(promptSession=" << (promptSession ? promptSession.get() : nullptr) << ")";
++    DEBUG_MSG << "(promptSession=" << promptSession.get() << ")";
      m_promptSessions.removeAll(promptSession);
+ }
@@ -474,26 +476,26 @@
          static_cast<Session*>(child)->stopPromptSessions();
+     }
--    QVector<std::shared_ptr<ms::PromptSession>> copy(m_promptSessions);
--    QVectorIterator<std::shared_ptr<ms::PromptSession>> it(copy);
++    QVector<qtmir::PromptSession> copy(m_promptSessions);
++    QVectorIterator<qtmir::PromptSession> it(copy);
      for ( it.toBack(); it.hasPrevious(); ) {
--        std::shared_ptr<ms::PromptSession> promptSession = it.previous();
++        qtmir::PromptSession promptSession = it.previous();
          DEBUG_MSG << " - promptSession=" << promptSession.get();
--        m_promptSessionManager->stop_prompt_session(promptSession);
++        m_promptSessionManager->stopPromptSession(promptSession);
+     }
+ }
--std::shared_ptr<ms::PromptSession> Session::activePromptSession() const
++qtmir::PromptSession Session::activePromptSession() const
+ {
      if (m_promptSessions.count() > 0)
          return m_promptSessions.back();
--    return nullptr;
++    return {};
+ }
--void Session::foreachPromptSession(const std::function<void(const std::shared_ptr<ms::PromptSession>&)>& f) const
++void Session::foreachPromptSession(const std::function<void(const qtmir::PromptSession&)>& f) const
+ {
--    Q_FOREACH (std::shared_ptr<ms::PromptSession> promptSession, m_promptSessions) {
++    Q_FOREACH (qtmir::PromptSession promptSession, m_promptSessions) {
          f(promptSession);
+     }
+ }
@@ -516,6 +518,18 @@
      return m_hadSurface;
+ }
++bool Session::focused() const
++{
++    for (int i = 0; i < m_surfaceList.count(); ++i) {
++        auto surface = static_cast<const MirSurfaceInterface*>(m_surfaceList.get(i));
++        if (surface->focused()) {
++            return true;
++        }
++    }
++
++    return false;
++}
++
  bool Session::activeFocus() const
+ {
      for (int i = 0; i < m_surfaceList.count(); ++i) {
@@ -530,7 +544,7 @@
  pid_t Session::pid() const
+ {
--    return m_session->process_id();
++    return miral::pid_of(m_session);
+ }
  void Session::setSuspendTimer(AbstractTimer *timer)
 === modified file 'src/modules/Unity/Application/session.h'
 --- src/modules/Unity/Application/session.h	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/session.h	2016-12-16 08:22:54 +0000
@@ -23,19 +23,17 @@
  // local
  #include "session_interface.h"
  #include "mirsurfacelistmodel.h"
++#include "promptsessionmanager.h"
  #include "timer.h"
  // Qt
  #include <QObject>
--namespace mir {
--    namespace scene {
--        class PromptSessionManager;
--    }
--}
  namespace qtmir {
++class PromptSessionManager;
++
  class Application;
  class Session : public SessionInterface
@@ -43,7 +41,7 @@
      Q_OBJECT
  public:
      explicit Session(const std::shared_ptr<mir::scene::Session>& session,
--                     const std::shared_ptr<mir::scene::PromptSessionManager>& promptSessionManager,
++                     const std::shared_ptr<PromptSessionManager>& promptSessionManager,
                       QObject *parent = 0);
      virtual ~Session();
@@ -66,6 +64,7 @@
      void stop() override;
      bool hadSurface() const override;
      bool hasClosingSurfaces() const override;
++    bool focused() const override;
      bool activeFocus() const override;
@@ -78,15 +77,15 @@
      std::shared_ptr<mir::scene::Session> session() const override;
--    std::shared_ptr<mir::scene::PromptSession> activePromptSession() const override;
--    void foreachPromptSession(const std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)> &f) const override;
++    PromptSession activePromptSession() const override;
++    void foreachPromptSession(const std::function<void(const PromptSession&)> &f) const override;
      SessionModel* childSessions() const override;
      void setFullscreen(bool fullscreen) override;
      void setLive(const bool) override;
--    void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
--    void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) override;
++    void appendPromptSession(const PromptSession& session) override;
++    void removePromptSession(const PromptSession& session) override;
      // useful for tests
      void setSuspendTimer(AbstractTimer *timer);
@@ -119,8 +118,8 @@
      State m_state;
      bool m_live;
      AbstractTimer* m_suspendTimer{nullptr};
--    QVector<std::shared_ptr<mir::scene::PromptSession>> m_promptSessions;
--    std::shared_ptr<mir::scene::PromptSessionManager> const m_promptSessionManager;
++    QVector<PromptSession> m_promptSessions;
++    std::shared_ptr<PromptSessionManager> const m_promptSessionManager;
      QList<MirSurfaceInterface*> m_closingSurfaces;
      bool m_hadSurface{false};
  };
 === modified file 'src/modules/Unity/Application/session_interface.h'
 --- src/modules/Unity/Application/session_interface.h	2016-07-15 15:38:04 +0000
 +++ src/modules/Unity/Application/session_interface.h	2016-12-16 08:22:54 +0000
@@ -33,7 +33,6 @@
  namespace mir {
      namespace scene {
          class Session;
--        class PromptSession;
+     }
+ }
@@ -41,6 +40,7 @@
  class MirSurfaceInterface;
  class MirSurfaceListModel;
++class PromptSession;
  class SessionInterface : public QObject {
      Q_OBJECT
@@ -78,7 +78,7 @@
      virtual std::shared_ptr<mir::scene::Session> session() const = 0;
--    // For MirSurface and MirSurfaceManager use
++    // For MirSurface use
      virtual void registerSurface(MirSurfaceInterface* surface) = 0;
@@ -91,6 +91,7 @@
      virtual void stop() = 0;
      virtual bool hadSurface() const = 0; // whether this session ever had any surface (currently or in the past)
      virtual bool hasClosingSurfaces() const = 0; // whether it has surfaces being forcibly closed
++    virtual bool focused() const = 0; // whether any surface in its list is focused()
      // Whether any of its MirSurfaces has activeFocus()
      // See qtmir::MirSurfaceInterface::activeFocus
@@ -105,19 +106,20 @@
      virtual void removeChildSession(SessionInterface* session) = 0;
      virtual void foreachChildSession(const std::function<void(SessionInterface* session)>& f) const = 0;
--    virtual std::shared_ptr<mir::scene::PromptSession> activePromptSession() const = 0;
--    virtual void foreachPromptSession(const std::function<void(const std::shared_ptr<mir::scene::PromptSession>&)>& f) const = 0;
++    virtual PromptSession activePromptSession() const = 0;
++    virtual void foreachPromptSession(const std::function<void(const PromptSession&)>& f) const = 0;
      virtual void setFullscreen(bool fullscreen) = 0;
      virtual void setLive(const bool) = 0;
--    virtual void appendPromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
--    virtual void removePromptSession(const std::shared_ptr<mir::scene::PromptSession>& session) = 0;
++    virtual void appendPromptSession(const PromptSession& session) = 0;
++    virtual void removePromptSession(const PromptSession& session) = 0;
  Q_SIGNALS:
      void applicationChanged(unity::shell::application::ApplicationInfoInterface* application);
      void stateChanged(State state);
      void fullscreenChanged(bool fullscreen);
      void liveChanged(bool live);
++    void focusedChanged(bool focused);
      // Emitted when any surface in this session emits focusRequested()
      void focusRequested();
 === modified file 'src/modules/Unity/Application/sessionmanager.cpp'
 --- src/modules/Unity/Application/sessionmanager.cpp	2016-08-10 06:51:55 +0000
 +++ src/modules/Unity/Application/sessionmanager.cpp	2016-12-16 08:22:54 +0000
@@ -23,28 +23,23 @@
  #include "sessionmanager.h"
  // QPA mirserver
++#include "appnotifier.h"
++#include "logging.h"
  #include "nativeinterface.h"
--#include "sessionlistener.h"
--#include "logging.h"
  #include "promptsessionlistener.h"
--
--// mir
--#include <mir/scene/prompt_session.h>
--#include <mir/scene/prompt_session_manager.h>
--#include <mir/report_exception.h>
--
--namespace ms = mir::scene;
++#include "promptsession.h"
++
  namespace qtmir {
  SessionManager *SessionManager::the_session_manager = nullptr;
--void connectToSessionListener(SessionManager *manager, SessionListener *listener)
++void connectToAppNotifier(SessionManager *manager, AppNotifier *appNotifier)
+ {
--    QObject::connect(listener, &SessionListener::sessionStarting,
++    QObject::connect(appNotifier, &AppNotifier::appAdded,
                       manager, &SessionManager::onSessionStarting);
--    QObject::connect(listener, &SessionListener::sessionStopping,
++    QObject::connect(appNotifier, &AppNotifier::appRemoved,
                       manager, &SessionManager::onSessionStopping);
+ }
@@ -61,7 +56,6 @@
+ }
  SessionManager* SessionManager::singleton()
--try
+ {
      if (!the_session_manager) {
@@ -73,27 +67,19 @@
              return nullptr;
+         }
--        SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
++        auto appNotifier = static_cast<AppNotifier*>(nativeInterface->nativeResourceForIntegration("AppNotifier"));
          PromptSessionListener *promptSessionListener = static_cast<PromptSessionListener*>(nativeInterface->nativeResourceForIntegration("PromptSessionListener"));
          the_session_manager = new SessionManager(nativeInterface->thePromptSessionManager(), ApplicationManager::singleton());
--        connectToSessionListener(the_session_manager, sessionListener);
++        connectToAppNotifier(the_session_manager, appNotifier);
          connectToPromptSessionListener(the_session_manager, promptSessionListener);
+     }
      return the_session_manager;
+ }
--catch (...)
--{
--    // We only call mir::report_exception() here to force linkage against libmirserver.
--    // Unless we force this module to have a link dependency on libmirserver we get
--    // several tests hanging during link loading. I wish I understood why.    alan_g
--    mir::report_exception();
--    throw;
--}
  SessionManager::SessionManager(
--        const std::shared_ptr<mir::scene::PromptSessionManager>& promptSessionManager,
++        const std::shared_ptr<qtmir::PromptSessionManager>& promptSessionManager,
          ApplicationManager* applicationManager,
          QObject *parent)
      : SessionModel(parent)
@@ -120,10 +106,11 @@
      return nullptr;
+ }
--void SessionManager::onSessionStarting(std::shared_ptr<mir::scene::Session> const& session)
++void SessionManager::onSessionStarting(const miral::ApplicationInfo &appInfo)
+ {
--    qCDebug(QTMIR_SESSIONS) << "SessionManager::onSessionStarting - sessionName=" <<  session->name().c_str();
++    qCDebug(QTMIR_SESSIONS) << "SessionManager::onSessionStarting - sessionName=" <<  appInfo.name().c_str();
++    const auto &session = appInfo.application();
      Session* qmlSession = new Session(session, m_promptSessionManager);
      insert(0, qmlSession);
@@ -140,11 +127,11 @@
      Q_EMIT sessionStarting(qmlSession);
+ }
--void SessionManager::onSessionStopping(std::shared_ptr<mir::scene::Session> const& session)
++void SessionManager::onSessionStopping(const miral::ApplicationInfo &appInfo)
+ {
--    qCDebug(QTMIR_SESSIONS) << "SessionManager::onSessionStopping - sessionName=" << session->name().c_str();
++    qCDebug(QTMIR_SESSIONS) << "SessionManager::onSessionStopping - sessionName=" << appInfo.name().c_str();
--    SessionInterface* qmlSession = findSession(session.get());
++    SessionInterface* qmlSession = findSession(appInfo.application().get());
      if (!qmlSession) return;
      remove(qmlSession);
@@ -153,11 +140,11 @@
      Q_EMIT sessionStopping(qmlSession);
+ }
--void SessionManager::onPromptSessionStarting(const std::shared_ptr<ms::PromptSession>& promptSession)
++void SessionManager::onPromptSessionStarting(const qtmir::PromptSession &promptSession)
+ {
      qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptSessionStarting - promptSession=" << promptSession.get();
--    std::shared_ptr<mir::scene::Session> appSession = m_promptSessionManager->application_for(promptSession);
++    std::shared_ptr<mir::scene::Session> appSession = m_promptSessionManager->applicationFor(promptSession);
      SessionInterface *qmlAppSession = findSession(appSession.get());
      if (qmlAppSession) {
          m_mirPromptToSessionHash[promptSession.get()] = qmlAppSession;
@@ -167,7 +154,7 @@
+     }
+ }
--void SessionManager::onPromptSessionStopping(const std::shared_ptr<ms::PromptSession>& promptSession)
++void SessionManager::onPromptSessionStopping(const qtmir::PromptSession &promptSession)
+ {
      qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptSessionStopping - promptSession=" << promptSession.get();
@@ -177,12 +164,12 @@
      m_mirPromptToSessionHash.remove(promptSession.get());
+ }
--void SessionManager::onPromptProviderAdded(const mir::scene::PromptSession *promptSession,
++void SessionManager::onPromptProviderAdded(const qtmir::PromptSession &promptSession,
                                                const std::shared_ptr<mir::scene::Session> &promptProvider)
+ {
--    qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - promptSession=" << promptSession << " promptProvider=" << promptProvider.get();
++    qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - promptSession=" << promptSession.get() << " promptProvider=" << promptProvider.get();
--    SessionInterface* qmlAppSession = m_mirPromptToSessionHash.value(promptSession, nullptr);
++    SessionInterface* qmlAppSession = m_mirPromptToSessionHash.value(promptSession.get(), nullptr);
      if (!qmlAppSession) {
          qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderAdded - could not find session item for app session";
          return;
@@ -197,10 +184,10 @@
      qmlAppSession->addChildSession(qmlPromptProvider);
+ }
--void SessionManager::onPromptProviderRemoved(const mir::scene::PromptSession *promptSession,
++void SessionManager::onPromptProviderRemoved(const qtmir::PromptSession &promptSession,
                                                  const std::shared_ptr<mir::scene::Session> &promptProvider)
+ {
--    qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderRemoved - promptSession=" << promptSession << " promptProvider=" << promptProvider.get();
++    qCDebug(QTMIR_SESSIONS) << "SessionManager::onPromptProviderRemoved - promptSession=" << promptSession.get() << " promptProvider=" << promptProvider.get();
      SessionInterface* qmlPromptProvider = findSession(promptProvider.get());
      if (!qmlPromptProvider) {
 === modified file 'src/modules/Unity/Application/sessionmanager.h'
 --- src/modules/Unity/Application/sessionmanager.h	2016-08-10 06:51:37 +0000
 +++ src/modules/Unity/Application/sessionmanager.h	2016-12-16 08:22:54 +0000
@@ -27,6 +27,9 @@
  // Mir
  #include <mir_toolkit/common.h>
++// miral
++#include <miral/application_info.h>
++
  // local
  #include "session.h"
  #include "sessionmodel.h"
@@ -49,7 +52,7 @@
  public:
      explicit SessionManager(
--        const std::shared_ptr<mir::scene::PromptSessionManager>& promptSessionManager,
++        const std::shared_ptr<PromptSessionManager>& promptSessionManager,
          ApplicationManager* applicationManager,
          QObject *parent = 0
      );
@@ -64,18 +67,18 @@
      void sessionStopping(SessionInterface* session);
  public Q_SLOTS:
--    void onSessionStarting(std::shared_ptr<mir::scene::Session> const& session);
--    void onSessionStopping(std::shared_ptr<mir::scene::Session> const& session);
++    void onSessionStarting(const miral::ApplicationInfo &appInfo);
++    void onSessionStopping(const miral::ApplicationInfo &appInfo);
--    void onPromptSessionStarting(const std::shared_ptr<mir::scene::PromptSession>& promptSession);
--    void onPromptSessionStopping(const std::shared_ptr<mir::scene::PromptSession>& promptSession);
--    void onPromptProviderAdded(const mir::scene::PromptSession *, const std::shared_ptr<mir::scene::Session> &);
--    void onPromptProviderRemoved(const mir::scene::PromptSession *, const std::shared_ptr<mir::scene::Session> &);
++    void onPromptSessionStarting(const PromptSession& promptSession);
++    void onPromptSessionStopping(const PromptSession& promptSession);
++    void onPromptProviderAdded(const qtmir::PromptSession &promptSession, const std::shared_ptr<mir::scene::Session> &);
++    void onPromptProviderRemoved(const qtmir::PromptSession &promptSession, const std::shared_ptr<mir::scene::Session> &);
  protected:
  private:
--    const std::shared_ptr<mir::scene::PromptSessionManager> m_promptSessionManager;
++    const std::shared_ptr<PromptSessionManager> m_promptSessionManager;
      ApplicationManager* m_applicationManager;
      static SessionManager *the_session_manager;
 === added file 'src/modules/Unity/Application/surfacemanager.cpp'
 --- src/modules/Unity/Application/surfacemanager.cpp	1970-01-01 00:00:00 +0000
 +++ src/modules/Unity/Application/surfacemanager.cpp	2016-12-16 08:22:54 +0000
@@ -0,0 +1,174 @@
++/*
++ * 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 "surfacemanager.h"
++
++#include "mirsurface.h"
++#include "sessionmanager.h"
++
++// mirserver
++#include "nativeinterface.h"
++
++// Qt
++#include <QGuiApplication>
++
++Q_LOGGING_CATEGORY(QTMIR_SURFACEMANAGER, "qtmir.surfacemanager", QtInfoMsg)
++
++#define DEBUG_MSG qCDebug(QTMIR_SURFACEMANAGER).nospace().noquote() << __func__
++
++using namespace qtmir;
++namespace unityapi = unity::shell::application;
++
++SurfaceManager::SurfaceManager(QObject *)
++{
++    DEBUG_MSG << "()";
++
++    auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
++
++    if (!nativeInterface) {
++        qFatal("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
++    }
++
++    m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
++
++    auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
++    connectToWindowModelNotifier(windowModel);
++
++    m_sessionManager = SessionManager::singleton();
++}
++
++void SurfaceManager::connectToWindowModelNotifier(WindowModelNotifier *notifier)
++{
++    connect(notifier, &WindowModelNotifier::windowAdded,          this, &SurfaceManager::onWindowAdded,           Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowRemoved,        this, &SurfaceManager::onWindowRemoved,         Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowReady,          this, &SurfaceManager::onWindowReady,           Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowMoved,          this, &SurfaceManager::onWindowMoved,           Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowStateChanged,   this, &SurfaceManager::onWindowStateChanged,    Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowFocusChanged,   this, &SurfaceManager::onWindowFocusChanged,    Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowsRaised,        this, &SurfaceManager::onWindowsRaised,         Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowRequestedRaise, this, &SurfaceManager::onWindowsRequestedRaise, Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::modificationsStarted, this, &SurfaceManager::modificationsStarted,    Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::modificationsEnded,   this, &SurfaceManager::modificationsEnded,      Qt::QueuedConnection);
++}
++
++void SurfaceManager::rememberMirSurface(MirSurface *surface)
++{
++    m_allSurfaces.append(surface);
++}
++
++void SurfaceManager::forgetMirSurface(const miral::Window &window)
++{
++    for (int i = 0; i < m_allSurfaces.count(); ++i) {
++        if (m_allSurfaces[i]->window() == window) {
++            m_allSurfaces.removeAt(i);
++            return;
++        }
++    }
++}
++void SurfaceManager::onWindowAdded(const NewWindow &window)
++{
++    auto mirSession = window.windowInfo.window().application();
++    SessionInterface* session = m_sessionManager->findSession(mirSession.get());
++
++    auto surface = new MirSurface(window, m_windowController, session);
++    rememberMirSurface(surface);
++
++    if (session)
++        session->registerSurface(surface);
++
++    Q_EMIT surfaceCreated(surface);
++}
++
++void SurfaceManager::onWindowRemoved(const miral::WindowInfo &windowInfo)
++{
++    MirSurface *surface = find(windowInfo);
++    forgetMirSurface(windowInfo.window());
++    surface->setLive(false);
++}
++
++MirSurface *SurfaceManager::find(const miral::WindowInfo &needle) const
++{
++    return find(needle.window());
++}
++
++MirSurface *SurfaceManager::find(const miral::Window &window) const
++{
++    Q_FOREACH(const auto surface, m_allSurfaces) {
++        if (surface->window() == window) {
++            return surface;
++        }
++    }
++    return nullptr;
++}
++
++void SurfaceManager::onWindowReady(const miral::WindowInfo &windowInfo)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setReady();
++    }
++}
++
++void SurfaceManager::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setPosition(topLeft);
++    }
++}
++
++void SurfaceManager::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setFocused(focused);
++    }
++}
++
++void SurfaceManager::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->updateState(state);
++    }
++}
++
++void SurfaceManager::onWindowsRaised(const std::vector<miral::Window> &windows)
++{
++    // sad inefficiency when crossing API boundaries (from miral to qt)
++    const int raiseCount = windows.size();
++    QVector<unityapi::MirSurfaceInterface*> surfaces(raiseCount);
++    for (int i = 0; i < raiseCount; i++) {
++        auto mirSurface = find(windows[i]);
++        surfaces.append(mirSurface);
++    }
++    Q_EMIT surfacesRaised(surfaces);
++}
++
++void SurfaceManager::onWindowsRequestedRaise(const miral::WindowInfo &windowInfo)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->requestFocus();
++    }
++}
++
++void SurfaceManager::raise(unityapi::MirSurfaceInterface *surface)
++{
++    auto qtmirSurface = static_cast<qtmir::MirSurface*>(surface);
++    m_windowController->raise(qtmirSurface->window());
++}
++
++void SurfaceManager::activate(unityapi::MirSurfaceInterface *surface)
++{
++    auto qtmirSurface = static_cast<qtmir::MirSurface*>(surface);
++    m_windowController->activate(qtmirSurface ? qtmirSurface->window() : miral::Window());
++}
 === added file 'src/modules/Unity/Application/surfacemanager.h'
 --- src/modules/Unity/Application/surfacemanager.h	1970-01-01 00:00:00 +0000
 +++ src/modules/Unity/Application/surfacemanager.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,73 @@
++/*
++ * 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 QTMIR_SURFACEMANAGER_H
++#define QTMIR_SURFACEMANAGER_H
++
++// common
++#include "windowmodelnotifier.h"
++
++// Unity API
++#include <unity/shell/application/SurfaceManagerInterface.h>
++
++#include <QVector>
++#include <QLoggingCategory>
++
++Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACEMANAGER)
++
++namespace qtmir {
++
++class MirSurface;
++class SessionManager;
++class WindowControllerInterface;
++
++class SurfaceManager : public unity::shell::application::SurfaceManagerInterface
++{
++    Q_OBJECT
++
++public:
++    explicit SurfaceManager(QObject *parent = 0);
++    virtual ~SurfaceManager() {}
++
++    void raise(unity::shell::application::MirSurfaceInterface *surface) override;
++    void activate(unity::shell::application::MirSurfaceInterface *surface) override;
++
++private Q_SLOTS:
++    void onWindowAdded(const qtmir::NewWindow &windowInfo);
++    void onWindowRemoved(const miral::WindowInfo &windowInfo);
++    void onWindowReady(const miral::WindowInfo &windowInfo);
++    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
++    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
++    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
++    void onWindowsRaised(const std::vector<miral::Window> &windows);
++    void onWindowsRequestedRaise(const miral::WindowInfo &windowInfo);
++
++private:
++    void connectToWindowModelNotifier(WindowModelNotifier *notifier);
++    void rememberMirSurface(MirSurface *surface);
++    void forgetMirSurface(const miral::Window &window);
++    MirSurface* find(const miral::WindowInfo &needle) const;
++    MirSurface* find(const miral::Window &needle) const;
++
++    QVector<MirSurface*> m_allSurfaces;
++
++    WindowControllerInterface *m_windowController;
++    SessionManager* m_sessionManager;
++};
++
++} // namespace qtmir
++
++#endif // QTMIR_SURFACEMANAGER_H
 === added file 'src/modules/Unity/Application/windowmodel.cpp'
 --- src/modules/Unity/Application/windowmodel.cpp	1970-01-01 00:00:00 +0000
 +++ src/modules/Unity/Application/windowmodel.cpp	2016-12-16 08:22:54 +0000
@@ -0,0 +1,235 @@
++/*
++ * 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 "windowmodel.h"
++
++#include "mirsurface.h"
++
++// mirserver
++#include "nativeinterface.h"
++
++// Qt
++#include <QGuiApplication>
++#include <QDebug>
++
++using namespace qtmir;
++
++WindowModel::WindowModel()
++{
++    auto nativeInterface = dynamic_cast<NativeInterface*>(QGuiApplication::platformNativeInterface());
++
++    if (!nativeInterface) {
++        qFatal("ERROR: Unity.Application QML plugin requires use of the 'mirserver' QPA plugin");
++    }
++
++    m_windowController = static_cast<WindowControllerInterface*>(nativeInterface->nativeResourceForIntegration("WindowController"));
++
++    auto windowModel = static_cast<WindowModelNotifier*>(nativeInterface->nativeResourceForIntegration("WindowModelNotifier"));
++    connectToWindowModelNotifier(windowModel);
++}
++
++WindowModel::WindowModel(WindowModelNotifier *notifier,
++                         WindowControllerInterface *controller)
++    : m_windowController(controller)
++{
++    connectToWindowModelNotifier(notifier);
++}
++
++void WindowModel::connectToWindowModelNotifier(WindowModelNotifier *notifier)
++{
++    connect(notifier, &WindowModelNotifier::windowAdded,        this, &WindowModel::onWindowAdded,        Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowRemoved,      this, &WindowModel::onWindowRemoved,      Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowReady,        this, &WindowModel::onWindowReady,        Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowMoved,        this, &WindowModel::onWindowMoved,        Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowStateChanged, this, &WindowModel::onWindowStateChanged, Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowFocusChanged, this, &WindowModel::onWindowFocusChanged, Qt::QueuedConnection);
++    connect(notifier, &WindowModelNotifier::windowsRaised,      this, &WindowModel::onWindowsRaised,      Qt::QueuedConnection);
++}
++
++QHash<int, QByteArray> WindowModel::roleNames() const
++{
++    QHash<int, QByteArray> roleNames;
++    roleNames.insert(SurfaceRole, "surface");
++    return roleNames;
++}
++
++void WindowModel::onWindowAdded(const NewWindow &window)
++{
++    if (window.windowInfo.type() == mir_surface_type_inputmethod) {
++        addInputMethodWindow(window);
++        return;
++    }
++
++    const int index = m_windowModel.count();
++    beginInsertRows(QModelIndex(), index, index);
++    m_windowModel.append(new MirSurface(window, m_windowController));
++    endInsertRows();
++    Q_EMIT countChanged();
++}
++
++void WindowModel::onWindowRemoved(const miral::WindowInfo &windowInfo)
++{
++    if (windowInfo.type() == mir_surface_type_inputmethod) {
++        removeInputMethodWindow();
++        return;
++    }
++
++    const int index = findIndexOf(windowInfo.window());
++
++    beginRemoveRows(QModelIndex(), index, index);
++    m_windowModel.takeAt(index);
++    endRemoveRows();
++    Q_EMIT countChanged();
++}
++
++void WindowModel::onWindowReady(const miral::WindowInfo &windowInfo)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setReady();
++    }
++}
++
++void WindowModel::onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setPosition(topLeft);
++    }
++}
++
++void WindowModel::onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->setFocused(focused);
++    }
++}
++
++void WindowModel::onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state)
++{
++    if (auto mirSurface = find(windowInfo)) {
++        mirSurface->updateState(state);
++    }
++}
++
++void WindowModel::addInputMethodWindow(const NewWindow &windowInfo)
++{
++    if (m_inputMethodSurface) {
++        qDebug("Multiple Input Method Surfaces created, removing the old one!");
++        delete m_inputMethodSurface;
++    }
++    m_inputMethodSurface = new MirSurface(windowInfo, m_windowController);
++    Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
++}
++
++void WindowModel::removeInputMethodWindow()
++{
++    if (m_inputMethodSurface) {
++        delete m_inputMethodSurface;
++        m_inputMethodSurface = nullptr;
++        Q_EMIT inputMethodSurfaceChanged(m_inputMethodSurface);
++    }
++}
++
++void WindowModel::onWindowsRaised(const std::vector<miral::Window> &windows)
++{
++    // Reminder: last item in the "windows" list should end up at the top of the model
++    const int modelCount = m_windowModel.count();
++    const int raiseCount = windows.size();
++
++    // Assumption: no NO-OPs are in this list - Qt will crash on endMoveRows() if you try NO-OPs!!!
++    // A NO-OP is if
++    //    1. "indices" is an empty list
++    //    2. "indices" of the form (..., modelCount - 2, modelCount - 1) which results in an unchanged list
++
++    // Precompute the list of indices of Windows/Surfaces to raise, including the offsets due to
++    // indices which have already been moved.
++    QVector<QPair<int /*from*/, int /*to*/>> moveList;
++
++    for (int i=raiseCount-1; i>=0; i--) {
++        int from = findIndexOf(windows[i]);
++        const int to = modelCount - raiseCount + i;
++
++        int moveCount = 0;
++        // how many list items under "index" have been moved so far, correct "from" to suit
++        for (int j=raiseCount-1; j>i; j--) {
++            if (findIndexOf(windows[j]) < from) {
++                moveCount++;
++            }
++        }
++        from -= moveCount;
++
++        if (from == to) {
++            // is NO-OP, would result in moving element to itself
++        } else {
++            moveList.prepend({from, to});
++        }
++    }
++
++    // Perform the moving, trusting the moveList is correct for each iteration.
++    QModelIndex parent;
++    for (int i=moveList.count()-1; i>=0; i--) {
++        const int from = moveList[i].first;
++        const int to = moveList[i].second;
++
++        beginMoveRows(parent, from, from, parent, to+1);
++#if QT_VERSION < QT_VERSION_CHECK(5, 6, 0)
++        const auto &window = m_windowModel.takeAt(from);
++        m_windowModel.insert(to, window);
++#else
++        m_windowModel.move(from, to);
++#endif
++
++        endMoveRows();
++    }
++}
++
++int WindowModel::rowCount(const QModelIndex &/*parent*/) const
++{
++    return m_windowModel.count();
++}
++
++QVariant WindowModel::data(const QModelIndex &index, int role) const
++{
++    if (index.row() < 0 || index.row() >= m_windowModel.count())
++        return QVariant();
++
++    if (role == SurfaceRole) {
++        auto &surface = m_windowModel.at(index.row());
++        return QVariant::fromValue(surface);
++    } else {
++        return QVariant();
++    }
++}
++
++MirSurface *WindowModel::find(const miral::WindowInfo &needle) const
++{
++    auto window = needle.window();
++    Q_FOREACH(const auto mirSurface, m_windowModel) {
++        if (mirSurface->window() == window) {
++            return mirSurface;
++        }
++    }
++    return nullptr;
++}
++
++int WindowModel::findIndexOf(const miral::Window &needle) const
++{
++    for (int i=0; i<m_windowModel.count(); i++) {
++        if (m_windowModel[i]->window() == needle) {
++            return i;
++        }
++    }
++    return -1;
++}
 === added file 'src/modules/Unity/Application/windowmodel.h'
 --- src/modules/Unity/Application/windowmodel.h	1970-01-01 00:00:00 +0000
 +++ src/modules/Unity/Application/windowmodel.h	2016-12-16 08:22:54 +0000
@@ -0,0 +1,83 @@
++/*
++ * 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 WINDOWMODEL_H
++#define WINDOWMODEL_H
++
++#include <QAbstractListModel>
++
++#include "mirsurface.h"
++#include "windowmodelnotifier.h"
++
++namespace qtmir {
++
++class WindowControllerInterface;
++
++class WindowModel : public QAbstractListModel
++{
++    Q_OBJECT
++
++    Q_PROPERTY(int count READ count NOTIFY countChanged)
++
++    Q_PROPERTY(MirSurfaceInterface* inputMethodSurface READ inputMethodSurface NOTIFY inputMethodSurfaceChanged)
++
++public:
++    enum Roles {
++        SurfaceRole = Qt::UserRole
++    };
++
++    WindowModel();
++    explicit WindowModel(WindowModelNotifier *notifier,
++                         WindowControllerInterface *controller); // For testing
++
++    // QAbstractItemModel methods
++    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
++    QVariant data(const QModelIndex& index, int role) const override;
++
++    QHash<int, QByteArray> roleNames() const override;
++
++    int count() const { return rowCount(); }
++
++    MirSurface* inputMethodSurface() const { return m_inputMethodSurface; }
++
++Q_SIGNALS:
++    void countChanged();
++    void inputMethodSurfaceChanged(MirSurfaceInterface* inputMethodSurface);
++
++private Q_SLOTS:
++    void onWindowAdded(const qtmir::NewWindow &windowInfo);
++    void onWindowRemoved(const miral::WindowInfo &windowInfo);
++    void onWindowReady(const miral::WindowInfo &windowInfo);
++    void onWindowMoved(const miral::WindowInfo &windowInfo, const QPoint topLeft);
++    void onWindowStateChanged(const miral::WindowInfo &windowInfo, Mir::State state);
++    void onWindowFocusChanged(const miral::WindowInfo &windowInfo, bool focused);
++    void onWindowsRaised(const std::vector<miral::Window> &windows);
++
++private:
++    void connectToWindowModelNotifier(WindowModelNotifier *notifier);
++
++    void addInputMethodWindow(const NewWindow &windowInfo);
++    void removeInputMethodWindow();
++    MirSurface* find(const miral::WindowInfo &needle) const;
++    int findIndexOf(const miral::Window &needle) const;
++
++    QVector<MirSurface*> m_windowModel;
++    WindowControllerInterface *m_windowController;
++    MirSurface* m_inputMethodSurface{nullptr};
++};
++
++} // namespace qtmir
++#endif // WINDOWMODEL_H
 === modified file 'src/modules/Unity/Screens/CMakeLists.txt'
 --- src/modules/Unity/Screens/CMakeLists.txt	2016-06-06 18:12:07 +0000
 +++ src/modules/Unity/Screens/CMakeLists.txt	2016-12-16 08:22:54 +0000
@@ -4,9 +4,9 @@
  include_directories(
      SYSTEM
++    ${MIRCLIENT_INCLUDE_DIRS}
      ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
      ${Qt5Quick_INCLUDE_DIRS}
--    ${MIRSERVER_INCLUDE_DIRS}
+     )
  set(SCREENSPLUGIN_SRC
 === modified file 'src/modules/Unity/Screens/plugin.cpp'
 --- src/modules/Unity/Screens/plugin.cpp	2016-04-29 15:41:00 +0000
 +++ src/modules/Unity/Screens/plugin.cpp	2016-12-16 08:22:54 +0000
@@ -36,7 +36,7 @@
          qRegisterMetaType<QScreen*>("QScreen*");
          qmlRegisterType<qtmir::Screens>(uri, 0, 1, "Screens");
--        qRegisterMetaType<qtmir::Screens::FormFactor>("Screens::FormFactor");
++        qRegisterMetaType<qtmir::FormFactor>("qtmir::FormFactor");
          qmlRegisterType<qtmir::QQuickScreenWindow>(uri, 0, 1, "ScreenWindow");
+     }
 === modified file 'src/modules/Unity/Screens/qquickscreenwindow.cpp'
 --- src/modules/Unity/Screens/qquickscreenwindow.cpp	2016-06-06 19:25:20 +0000
 +++ src/modules/Unity/Screens/qquickscreenwindow.cpp	2016-12-16 08:22:54 +0000
@@ -48,7 +48,7 @@
  QQuickScreenWindow::QQuickScreenWindow(QQuickWindow *parent)
      : QQuickWindow(parent)
      , m_scale(-1.0) // start with invalid initial state, fetch correct value on first invokation
--    , m_formFactor(Screens::FormFactorUnknown)
++    , m_formFactor(FormFactorUnknown)
+ {
      if (qGuiApp->platformName() == QLatin1String("mirserver")) {
          connect(qGuiApp->platformNativeInterface(), &QPlatformNativeInterface::windowPropertyChanged,
@@ -91,7 +91,7 @@
      return m_scale;
+ }
--bool QQuickScreenWindow::setScaleAndFormFactor(const float scale, const Screens::FormFactor formFactor)
++bool QQuickScreenWindow::setScaleAndFormFactor(const float scale, const FormFactor formFactor)
+ {
      if (qFuzzyCompare(scale, m_scale) && formFactor == m_formFactor) {
          return true;
@@ -125,9 +125,9 @@
      return controller->setConfiguration(configs);
+ }
--Screens::FormFactor QQuickScreenWindow::formFactor()
++FormFactor QQuickScreenWindow::formFactor()
+ {
--    if (m_formFactor == Screens::FormFactorUnknown) {
++    if (m_formFactor == FormFactorUnknown) {
          m_formFactor = getFormFactorNativeProperty();
+     }
      return m_formFactor;
@@ -173,7 +173,7 @@
      return scale;
+ }
--Screens::FormFactor QQuickScreenWindow::getFormFactorNativeProperty() const
++FormFactor QQuickScreenWindow::getFormFactorNativeProperty() const
+ {
      QVariant formFactorVal = qGuiApp->platformNativeInterface()
                                  ->windowProperty(handle(), QStringLiteral("formFactor"));
@@ -181,5 +181,5 @@
          return m_formFactor;
+     }
--    return static_cast<Screens::FormFactor>(formFactorVal.toInt());
++    return static_cast<FormFactor>(formFactorVal.toInt());
+ }
 === modified file 'src/modules/Unity/Screens/qquickscreenwindow.h'
 --- src/modules/Unity/Screens/qquickscreenwindow.h	2016-01-28 23:32:53 +0000
 +++ src/modules/Unity/Screens/qquickscreenwindow.h	2016-12-16 08:22:54 +0000
@@ -28,7 +28,7 @@
      Q_PROPERTY(QScreen *screen READ screen WRITE setScreen NOTIFY screenChanged)
      Q_PROPERTY(float scale READ scale NOTIFY scaleChanged)
--    Q_PROPERTY(Screens::FormFactor formFactor READ formFactor NOTIFY formFactorChanged)
++    Q_PROPERTY(FormFactor formFactor READ formFactor NOTIFY formFactorChanged)
  public:
      explicit QQuickScreenWindow(QQuickWindow *parent = 0);
@@ -37,13 +37,13 @@
      void setScreen(QScreen *screen);
      qreal scale();
--    Screens::FormFactor formFactor();
--    Q_INVOKABLE bool setScaleAndFormFactor(const float scale, const Screens::FormFactor formFactor);
++    FormFactor formFactor();
++    Q_INVOKABLE bool setScaleAndFormFactor(const float scale, const FormFactor formFactor);
  Q_SIGNALS:
      void screenChanged(QScreen *screen);
      void scaleChanged(qreal scale);
--    void formFactorChanged(Screens::FormFactor arg);
++    void formFactorChanged(FormFactor arg);
  private Q_SLOTS:
      void nativePropertyChanged(QPlatformWindow *window, const QString &propertyName);
@@ -51,8 +51,8 @@
  private:
      float getScaleNativeProperty() const;
      float m_scale;
--    Screens::FormFactor getFormFactorNativeProperty() const;
--    Screens::FormFactor m_formFactor;
++    FormFactor getFormFactorNativeProperty() const;
++    FormFactor m_formFactor;
  };
  } //namespace qtmir
 === modified file 'src/modules/Unity/Screens/screens.cpp'
 --- src/modules/Unity/Screens/screens.cpp	2016-04-29 15:41:00 +0000
 +++ src/modules/Unity/Screens/screens.cpp	2016-12-16 08:22:54 +0000
@@ -62,7 +62,7 @@
      case OutputTypeRole: {
          auto screen = static_cast<Screen*>(m_screenList.at(index.row())->handle());
          if (screen) {
--            return QVariant(static_cast<OutputTypes>(screen->outputType())); //FIXME: cheeky
++            return QVariant(screen->outputType());
          } else {
              return OutputTypes::Unknown;
+         }
 === modified file 'src/modules/Unity/Screens/screens.h'
 --- src/modules/Unity/Screens/screens.h	2016-04-29 15:41:00 +0000
 +++ src/modules/Unity/Screens/screens.h	2016-12-16 08:22:54 +0000
@@ -17,6 +17,8 @@
  #ifndef SCREENS_H
  #define SCREENS_H
++#include "screentypes.h"
++
  #include <QAbstractListModel>
  class QScreen;
@@ -39,33 +41,6 @@
          FormFactorRole,
      };
--    enum OutputTypes {
--        Unknown,
--        VGA,
--        DVII,
--        DVID,
--        DVIA,
--        Composite,
--        SVideo,
--        LVDS,
--        Component,
--        NinePinDIN,
--        DisplayPort,
--        HDMIA,
--        HDMIB,
--        TV,
--        EDP
--    };
--
--    enum FormFactor {
--        FormFactorUnknown,
--        FormFactorPhone,
--        FormFactorTablet,
--        FormFactorMonitor,
--        FormFactorTV,
--        FormFactorProjector,
--    };
--
      explicit Screens(QObject *parent = 0);
      virtual ~Screens() noexcept = default;
@@ -91,6 +66,4 @@
  } // namespace qtmir
--Q_DECLARE_METATYPE(qtmir::Screens::FormFactor)
--
  #endif // SCREENS_H
 === modified file 'src/platforms/mirserver/CMakeLists.txt'
 --- src/platforms/mirserver/CMakeLists.txt	2016-09-08 22:46:57 +0000
 +++ src/platforms/mirserver/CMakeLists.txt	2016-12-16 08:22:54 +0000
@@ -25,11 +25,11 @@
  include_directories(
      ${CMAKE_SOURCE_DIR}/src/common
--
+ )
  include_directories(
--  SYSTEM
++    SYSTEM
++    ${MIRAL_INCLUDE_DIRS}
      ${MIRCOMMON_INCLUDE_DIRS}
      ${MIRSERVER_INCLUDE_DIRS}
      ${MIRRENDERERGLDEV_INCLUDE_DIRS}
@@ -53,56 +53,70 @@
  # Needed to compile tracepoints in C99 mode.
  add_definitions(-DBYTE_ORDER=__BYTE_ORDER)
--set(MIRSERVER_QPA_PLUGIN_SRC
--    ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
++# These files will compile without mirserver-dev
++add_library(qpa-mirserver-nomirserver OBJECT
      ${CMAKE_SOURCE_DIR}/src/common/timestamp.cpp
--    cursor.cpp
--    eventbuilder.cpp
      logging.cpp
++    plugin.cpp
++    shelluuid.cpp
++    ubuntutheme.cpp
++    clipboard.cpp
++    openglcontextfactory.cpp openglcontextfactory.h
      mircursorimages.cpp
      mirdisplayconfigurationpolicy.cpp
--    mirwindowmanager.cpp
      mirsingleton.cpp
++    sessionauthorizer.cpp
++    promptsessionlistener.cpp
++    mirserverstatuslistener.cpp
++    screenscontroller.cpp
++    nativeinterface.cpp
++    qtcompositor.cpp
++    services.cpp
++    windowcontroller.cpp
++    windowmanagementpolicy.cpp
++    mirserverhooks.cpp mirserverhooks.h
++    setqtcompositor.cpp setqtcompositor.h
++    tracepoints.c
++# We need to run moc on these headers
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
++    ${CMAKE_SOURCE_DIR}/src/common/appnotifier.h
++    ${CMAKE_SOURCE_DIR}/src/common/windowcontrollerinterface.h
++    ${CMAKE_SOURCE_DIR}/src/common/windowmodelnotifier.h
++)
++set_source_files_properties(tracepoints.c PROPERTIES COMPILE_FLAGS "${CMAKE_CFLAGS} -fPIC")
++
++include_directories(SYSTEM ${MIRSERVER_INCLUDE_DIRS})
++
++set(MIRSERVER_QPA_PLUGIN_SRC
++    ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
++    cursor.cpp
++    eventbuilder.cpp
      qteventfeeder.cpp
--    plugin.cpp
      qmirserver.cpp
      qmirserver_p.cpp
--    sessionauthorizer.cpp
--    sessionlistener.cpp
--    shelluuid.cpp
      surfaceobserver.cpp
--    promptsessionlistener.cpp
--    mirserver.cpp
--    mirserverstatuslistener.cpp
      screen.cpp
      screenwindow.cpp
--    screenscontroller.cpp
      screensmodel.cpp
      mirserverintegration.cpp
      miropenglcontext.cpp
--    nativeinterface.cpp
      offscreensurface.cpp
--    qtcompositor.cpp
--    services.cpp
--    ubuntutheme.cpp
--    clipboard.cpp
--    creationhints.cpp
--    tracepoints.c
++    promptsessionmanager.cpp promptsessionmanager.h promptsession.h
  # We need to run moc on these headers
--    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
--    )
++)
  add_library(qpa-mirserver SHARED
      ${MIRSERVER_QPA_PLUGIN_SRC}
++    $<TARGET_OBJECTS:qpa-mirserver-nomirserver>
+ )
  target_link_libraries(
      qpa-mirserver
      Qt5PlatformSupport
++    ${MIRAL_LDFLAGS}
      ${MIRSERVER_LDFLAGS}
--    ${MIRCLIENT_LDFLAGS}
      ${URL_DISPATCHER_LDFLAGS}
      ${EGL_LDFLAGS}
      ${GL_LIBRARIES}
 === removed file 'src/platforms/mirserver/creationhints.cpp'
 --- src/platforms/mirserver/creationhints.cpp	2016-06-06 19:25:20 +0000
 +++ src/platforms/mirserver/creationhints.cpp	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
--/*
-- * 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 <mir/scene/surface_creation_parameters.h>
--
--#include "creationhints.h"
--
--using namespace qtmir;
--
--inline const char* shellChromeToString(Mir::ShellChrome chrome) {
--    switch (chrome) {
--        case Mir::ShellChrome::NormalChrome:
--            return "normal";
--        case Mir::ShellChrome::LowChrome:
--            return "low";
--    }
--    return "unknown";
--}
--
--CreationHints::CreationHints(const mir::scene::SurfaceCreationParameters &params)
--{
--    minWidth = params.min_width.is_set() ? params.min_width.value().as_int() : 0;
--    maxWidth = params.max_width.is_set() ? params.max_width.value().as_int() : 0;
--
--    minHeight = params.min_height.is_set() ? params.min_height.value().as_int() : 0;
--    maxHeight = params.max_height.is_set() ? params.max_height.value().as_int() : 0;
--
--    widthIncrement = params.width_inc.is_set() ? params.width_inc.value().as_int() : 0;
--    heightIncrement = params.height_inc.is_set() ? params.height_inc.value().as_int() : 0;
--
--    if (params.shell_chrome.is_set()) {
--        switch (params.shell_chrome.value()) {
--            case mir_shell_chrome_normal:
--            default:
--                shellChrome = Mir::ShellChrome::NormalChrome;
--                break;
--            case mir_shell_chrome_low:
--                shellChrome = Mir::ShellChrome::LowChrome;
--                break;
--        }
--    }
--}
--
--QString CreationHints::toString() const
--{
--    return QStringLiteral("CreationHints(minW=%1,minH=%2,maxW=%3,maxH=%4,wIncr=%5,hInc=%6,shellChrome=%7)")
--        .arg(minWidth)
--        .arg(minHeight)
--        .arg(maxWidth)
--        .arg(maxHeight)
--        .arg(widthIncrement)
--        .arg(heightIncrement)
--        .arg(shellChromeToString(shellChrome));
--}
 === removed file 'src/platforms/mirserver/creationhints.h'
 --- src/platforms/mirserver/creationhints.h	2016-06-06 19:25:20 +0000
 +++ src/platforms/mirserver/creationhints.h	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
--/*
-- * 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 QTMIR_CREATIONHINTS_H
--#define QTMIR_CREATIONHINTS_H
--
--#include <QMetaType>
--#include <QString>
--
--#include <unity/shell/application/Mir.h>
--
--namespace mir {
--    namespace scene {
--        struct SurfaceCreationParameters;
--    }
--}
--
--namespace qtmir {
--
--class CreationHints {
--public:
--    CreationHints() {}
--    CreationHints(const mir::scene::SurfaceCreationParameters&);
--
--    QString toString() const;
--
--    int minWidth{0};
--    int maxWidth{0};
--
--    int minHeight{0};
--    int maxHeight{0};
--
--    int widthIncrement{0};
--    int heightIncrement{0};
--
--    Mir::ShellChrome shellChrome{Mir::ShellChrome::NormalChrome};
--};
--
--} // namespace qtmir
--
--Q_DECLARE_METATYPE(qtmir::CreationHints)
--
--#endif // QTMIR_CREATIONHINTS_H
 === modified file 'src/platforms/mirserver/cursor.cpp'
 --- src/platforms/mirserver/cursor.cpp	2016-08-08 13:10:40 +0000
 +++ src/platforms/mirserver/cursor.cpp	2016-12-16 08:22:54 +0000
@@ -69,7 +69,7 @@
              // just different from the previous custom cursor name, which is enough to trigger a change in the cursor
              // source image URL in the QML side which on is turn makes QML request the new cursor image.
              static quint8 serialNumber = 1;
--            m_qtCursorName = QStringLiteral("custom%1").arg(serialNumber++);
++            m_qtCursorName = QString("custom%1").arg(serialNumber++);
              m_mousePointer->setCustomCursor(*windowCursor);
+         }
      } else {
 === modified file 'src/platforms/mirserver/customscreenconfiguration.h'
 --- src/platforms/mirserver/customscreenconfiguration.h	2016-01-11 14:29:06 +0000
 +++ src/platforms/mirserver/customscreenconfiguration.h	2016-12-16 08:22:54 +0000
@@ -20,11 +20,13 @@
  #include <QPoint>
  #include <QVector>
--#include <mir/graphics/display_configuration.h>
++#include "screentypes.h"
++#include <mir_toolkit/common.h>
++
  struct CustomScreenConfiguration
+ {
--    mir::graphics::DisplayConfigurationOutputId id;
++    qtmir::OutputId id;
      QPoint topLeft;
      uint32_t currentModeIndex;
 === modified file 'src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp'
 --- src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp	2016-04-29 15:41:00 +0000
 +++ src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp	2016-12-16 08:22:54 +0000
@@ -16,8 +16,10 @@
  #include "mirdisplayconfigurationpolicy.h"
++#include <mir/graphics/display_configuration_policy.h>
  #include <mir/graphics/display_configuration.h>
  #include <mir/geometry/point.h>
++#include <mir/server.h>
  #include <qglobal.h>
  #include <QByteArray>
@@ -28,6 +30,18 @@
  #define DEFAULT_GRID_UNIT_PX 8
  namespace {
++class MirDisplayConfigurationPolicy : public mir::graphics::DisplayConfigurationPolicy
++{