QtMir

Merge lp:~unity-team/qtmir/qtmir.api into lp:qtmir

qtmir.api
Merge into trunk

Proposed by Nick Dedekind on 2017-01-26

Status:	Needs review
Proposed branch:	lp:~unity-team/qtmir/qtmir.api
Merge into:	lp:qtmir
Prerequisite:	lp:~nick-dedekind/qtmir/miral-DisplayConfigurationStorage
Diff against target:	3478 lines (+1743/-612) 53 files modified CMakeLists.txt (+3/-1) debian/changelog (+7/-0) debian/control (+29/-0) debian/gles-patches/convert-to-gles.patch (+27/-17) debian/libqtmirserver-dev.install (+3/-0) debian/libqtmirserver1.install (+1/-0) debian/qtmir-tests.install (+1/-1) debian/rules (+2/-0) demos/CMakeLists.txt (+1/-1) demos/qml-demo-client/main.cpp (+2/-2) demos/qml-demo-shell/CMakeLists.txt (+9/-0) demos/qml-demo-shell/main.cpp (+83/-10) include/qtmir/displayconfigurationpolicy.h (+70/-10) include/qtmir/displayconfigurationstorage.h (+61/-0) include/qtmir/miral/display_configuration_policy.h (+42/-0) include/qtmir/miral/display_configuration_storage.h (+6/-1) include/qtmir/mirserverapplication.h (+49/-0) include/qtmir/sessionauthorizer.h (+63/-20) include/qtmir/windowmanagementpolicy.h (+129/-0) src/modules/Unity/Application/CMakeLists.txt (+3/-1) src/modules/Unity/Application/taskcontroller.cpp (+1/-1) src/modules/Unity/Screens/CMakeLists.txt (+1/-1) src/platforms/mirserver/CMakeLists.txt (+103/-44) src/platforms/mirserver/displayconfigurationpolicy.cpp (+53/-39) src/platforms/mirserver/displayconfigurationstorage.cpp (+46/-0) src/platforms/mirserver/miral/CMakeLists.txt (+7/-2) src/platforms/mirserver/miral/display_configuration_policy.cpp (+21/-0) src/platforms/mirserver/miral/edid.cpp (+1/-1) src/platforms/mirserver/miral/persist_display_config.cpp (+57/-22) src/platforms/mirserver/miral/persist_display_config.h (+3/-4) src/platforms/mirserver/mirserverapplication.cpp (+53/-0) src/platforms/mirserver/mirserverintegration.cpp (+1/-1) src/platforms/mirserver/mirserverintegration.h (+2/-1) src/platforms/mirserver/qmirserver.cpp (+51/-0) src/platforms/mirserver/qmirserver.h (+24/-3) src/platforms/mirserver/qmirserver_p.cpp (+57/-16) src/platforms/mirserver/qmirserver_p.h (+12/-6) src/platforms/mirserver/qtmirserver.pc.in (+9/-0) src/platforms/mirserver/screensmodel.cpp (+1/-2) src/platforms/mirserver/windowcontroller.cpp (+2/-2) src/platforms/mirserver/windowcontroller.h (+4/-4) src/platforms/mirserver/wrappedsessionauthorizer.cpp (+134/-72) src/platforms/mirserver/wrappedsessionauthorizer.h (+39/-0) src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp (+446/-297) src/platforms/mirserver/wrappedwindowmanagementpolicy.h (+13/-22) tests/mirserver/EventBuilder/CMakeLists.txt (+1/-1) tests/mirserver/QtEventFeeder/CMakeLists.txt (+1/-1) tests/mirserver/Screen/CMakeLists.txt (+3/-1) tests/mirserver/ScreensModel/CMakeLists.txt (+1/-1) tests/mirserver/miral/CMakeLists.txt (+2/-2) tests/mirserver/miral/edid_test.cpp (+1/-1) tests/modules/Application/CMakeLists.txt (+1/-1) tests/modules/WindowManager/CMakeLists.txt (+1/-0)
To merge this branch:	bzr merge lp:~unity-team/qtmir/qtmir.api
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot (community)	continuous-integration		Approve on 2017-04-05
Gerry Boland (community)			Needs Fixing on 2017-03-22
Daniel d'Andrada (community)			Abstain on 2017-02-22
Michael Terry (community)	packaging	2017-01-26	Needs Fixing on 2017-02-15
Review via email: mp+315681@code.launchpad.net

Commit message

API for qtmir

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-02-14:

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

review: Needs Fixing (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-02-14

625. By Nick Dedekind on 2017-02-14: merged parent

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-02-14:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

=== modified file 'debian/control'
+Package: qtmir-dev
I suspect qtmir will evolve into a more typical library in time. Can you rename to libqtmir-dev

+Replaces: qtmir-android-dev,
where did you find this package? qtmir never had a -dev package before.

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

Copyrights need bumping to 2017

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

== added file 'include/qtmir/guiserverapplication.h'
+class GuiServerApplication : public QGuiApplication

"Gui" is redundant here, I'd rather "MirServerApplication"

Good work on establishing an API that is as flexible as MirAL's.

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

+++ src/platforms/mirserver/displayconfigurationstorage.cpp

last line
+}
missing a "// namespace qtmir"

+++ src/platforms/mirserver/guiserverapplication.cpp
+QSharedPointer<QMirServer> mirServer;
does it need to be shared?

around line 36, please add "// namespace" after the anonymous closing brace. And at EOF, another comment please. I get lost with namespaces.

+ : QGuiApplication((init(argc, argv, options), argc), argv) // comma operator to ensure init called before QGuiApplication
clever!

+++ src/platforms/mirserver/miral/persist_display_config.cpp
+ if (mode.size == newMode.size && mode.vrefresh_hz == newMode.refresh_rate) {
refresh_rate comparison is a floating point comparison, could be unreliable. Can you use something like qFuzzyCompare?

+++ src/platforms/mirserver/mirserverintegration.h
- QScopedPointer<QMirServer> m_mirServer;
+ QSharedPointer<QMirServer> m_mirServer;
Does it really need to be shared? AFAICS nobody else makes a copy of the QSharedPointer after construction.

+++ src/platforms/mirserver/qmirserver.h
+ static QSharedPointer<QMirServer> create(int &argc,
+ char **argv);
It's your big entry point header file, make it pretty! Do line up these arguments, or just have on single line.

+++ src/platforms/mirserver/qmirserver_p.cpp
+auto buildDisplayConfigurationPolicy()
+-> std::shared_ptr<miral::DisplayConfigurationPolicy>
I'm not a fan of this method definition style. Please stick to the old fashioned one.

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

+++ src/platforms/mirserver/qtmirserver.pc.in
We need to standardize names. "qtmir" was never a great name, it is unclear if mir server or client. "qtmirserver" is ideal, but I know I am annoyed when the debian package name doesn't match the name used for the pkgconfig.

Should we call the debian package libqtmirserver then?

+Requires: miral
We should require miral version 1.1

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-02-14:

+ WrappedWindowManagementPolicy(const miral::WindowManagerTools &tools,
+ qtmir::WindowModelNotifier &windowModel,
+ qtmir::WindowController &windowController,
+ qtmir::AppNotifier &appNotifier,
+ const std::shared_ptr<QtEventFeeder>& eventFeeder,
+ const qtmir::WindowManagmentPolicyBuilder& wmBuilder);

Last two lines need & on the right, to be consistent

Revision history for this message

Michael Terry (mterry) wrote on 2017-02-15:

Looking at the packaging...

+Package: qtmir-dev

This should probably be called libqtmirserver-dev instead.

+Replaces: qtmir-android-dev,

What's qtmir-android-dev from?

+Depends: qtmir-desktop (= ${source:Version}) | qtmir-android (= ${source:Version}),

I believe you want binary:Version here.

+Description: Developer files for the Qt platform abstraction plugin for a
+ Mir server.
+ .
+ Contains header files required for development using QtMir.

The first line of the description is special, don't break it across lines. I'd do something like:

Description: Header files for QtMir
QtMir is a set of Qt5 components to enable one to write a Mir server with Qt.
It contains a QPA (Qt Platform Abstraction) plugin which creates and manages
a Mir server. It also exposes some internal Mir functionality.
.
This package contains the library headers for developers.

review: Needs Fixing (packaging)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2017-02-21:

There are conflicts with latest trunk.

"""
Text conflict in src/modules/Unity/Application/CMakeLists.txt
Text conflict in src/platforms/mirserver/CMakeLists.txt
Text conflict in src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp
"""

review: Needs Fixing

lp:~unity-team/qtmir/qtmir.api updated on 2017-02-22

626. By Nick Dedekind on 2017-02-22: merged trunk
627. By Nick Dedekind on 2017-02-22: packaging fixes
628. By Nick Dedekind on 2017-02-22: updated gles patch
629. By Nick Dedekind on 2017-02-22: GuiServerApplication->MirServerApplication
630. By Nick Dedekind on 2017-02-22: comment updates

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-02-22:

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

review: Approve (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-02-22:

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

review: Approve (continuous-integration)

Revision history for this message

Daniel d'Andrada (dandrader) wrote on 2017-02-22:

Merges fine now.

review: Abstain

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-01

631. By Nick Dedekind on 2017-03-01: merged with parent

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-01:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-03

632. By Michael Zanetti on 2017-03-03: add a dep to libmiral-dev

Revision history for this message

Michael Zanetti (mzanetti) wrote on 2017-03-03:

I've added a dep from to libqtmirserver-dev for libmiral-dev as pkgconfig for libqtmirserver requires that.

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-03:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-10

633. By Nick Dedekind on 2017-03-10: libqtmirserver1
634. By Nick Dedekind on 2017-03-10: updated gles patch

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-10:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-16

635. By Nick Dedekind on 2017-03-16: merged with parent

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-16:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-20

636. By Nick Dedekind on 2017-03-20: merged with parent
637. By Nick Dedekind on 2017-03-20: removed appnotifier and window notifier

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-20:

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

review: Approve (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-20:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-21

638. By Nick Dedekind on 2017-03-21: review comments
639. By Nick Dedekind on 2017-03-21: consistency

Revision history for this message

Nick Dedekind (nick-dedekind) wrote on 2017-03-21:

> +++ src/platforms/mirserver/displayconfigurationstorage.cpp
>
> last line
> +}
> missing a "// namespace qtmir"
>
>
> +++ src/platforms/mirserver/guiserverapplication.cpp
> +QSharedPointer<QMirServer> mirServer;
> does it need to be shared?

Both the QGuiApp and MirServerIntegration call QMirServer::create, which only holds a weak pointer. If the GuiApp or MirServerIntegration didnt hold shared pointers the QMirServer would be released once the init function is completed and then re-created by the QMirServerIntegration.

>
> around line 36, please add "// namespace" after the anonymous closing brace.
> And at EOF, another comment please. I get lost with namespaces.
>
>
> + : QGuiApplication((init(argc, argv, options), argc), argv) // comma operator
> to ensure init called before QGuiApplication
> clever!
>
>
> +++ src/platforms/mirserver/miral/persist_display_config.cpp
> + if (mode.size == newMode.size && mode.vrefresh_hz == newMode.refresh_rate) {
> refresh_rate comparison is a floating point comparison, could be unreliable.
> Can you use something like qFuzzyCompare?
>

I've included qglobal and used qFuzzyCompare. Shouldn't really be doing that in the miral namespace. Mir doesn't seem to care about dodgey float compare :/

>
> +++ src/platforms/mirserver/mirserverintegration.h
> - QScopedPointer<QMirServer> m_mirServer;
> + QSharedPointer<QMirServer> m_mirServer;
> Does it really need to be shared? AFAICS nobody else makes a copy of the
> QSharedPointer after construction.

It's held by the MirServerApplication if it's being used.

>
>
> +++ src/platforms/mirserver/qmirserver.h
> + static QSharedPointer<QMirServer> create(int &argc,
> + char **argv);
> It's your big entry point header file, make it pretty! Do line up these
> arguments, or just have on single line.
>

Done

>
> +++ src/platforms/mirserver/qmirserver_p.cpp
> +auto buildDisplayConfigurationPolicy()
> +-> std::shared_ptr<miral::DisplayConfigurationPolicy>
> I'm not a fan of this method definition style. Please stick to the old
> fashioned one.

Done

> +++ src/platforms/mirserver/displayconfigurationstorage.cpp
> 
> last line
> +}
> missing a "// namespace qtmir"
> 
> 
> +++ src/platforms/mirserver/guiserverapplication.cpp
> +QSharedPointer<QMirServer> mirServer;
> does it need to be shared?

> 
> around line 36, please add "// namespace" after the anonymous closing brace.
> And at EOF, another comment please. I get lost with namespaces.
> 
> 
> + : QGuiApplication((init(argc, argv, options), argc), argv) // comma operator
> to ensure init called before QGuiApplication
> clever!
> 
> 
> +++ src/platforms/mirserver/miral/persist_display_config.cpp
> + if (mode.size == newMode.size && mode.vrefresh_hz == newMode.refresh_rate) {
> refresh_rate comparison is a floating point comparison, could be unreliable.
> Can you use something like qFuzzyCompare?
>

I've included qglobal and used qFuzzyCompare. Shouldn't really be doing that in the miral namespace. Mir doesn't seem to care about dodgey float compare :/

> 
> +++ src/platforms/mirserver/mirserverintegration.h
> -    QScopedPointer<QMirServer> m_mirServer;
> +    QSharedPointer<QMirServer> m_mirServer;
> Does it really need to be shared? AFAICS nobody else makes a copy of the
> QSharedPointer after construction.

It's held by the MirServerApplication if it's being used.

> 
> 
> +++ src/platforms/mirserver/qmirserver.h
> +    static QSharedPointer<QMirServer> create(int &argc,
> +                                           char **argv);
> It's your big entry point header file, make it pretty! Do line up these
> arguments, or just have on single line.
>

Done

> 
> +++ src/platforms/mirserver/qmirserver_p.cpp
> +auto buildDisplayConfigurationPolicy()
> +-> std::shared_ptr<miral::DisplayConfigurationPolicy>
> I'm not a fan of this method definition style. Please stick to the old
> fashioned one.

Done

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-21:

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

review: Approve (continuous-integration)

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-03-22:

+class BasicSetDisplayConfigurationStorage
+{
+public:
+ explicit BasicSetDisplayConfigurationStorage(DisplayConfigurationStorageBuilder const& builder);
+ ~BasicSetDisplayConfigurationStorage() = default;
+
+ void operator()(QMirServer& server);

You're making your life harder having the builder-applyer take QMirServer, instead of mir::Server. All of MirAL's building blocks use mir::Server, so if we go this route, we end up having to replace all of MirAL's bits. I think that's a bad idea.

review: Needs Fixing

Revision history for this message

Gerry Boland (gerboland) wrote on 2017-03-22:

Ok, on further reflection I think I see why you've done that. Because you want to register that implementation with QMirServer, so that you can refer to it later (i.e. it doesn't disappear into the depths of Mir can we cannot get at it again).

Can MirAL give us more api maybe? /me needs to think

Revision history for this message

Albert Astals Cid (aacid) wrote on 2017-03-24:

Text conflict in src/platforms/mirserver/miral/CMakeLists.txt
Text conflict in src/platforms/mirserver/qmirserver_p.cpp
Text conflict in src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp
3 conflicts encountered.

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-24

640. By Nick Dedekind on 2017-03-24: merged parent

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-24:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-03-24

641. By Nick Dedekind on 2017-03-24: added build dir to cmake path

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-24:

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

review: Approve (continuous-integration)

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-31:

FAILED: Continuous integration, rev:641
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/649/
Executed test runs:
FAILURE: https://unity8-jenkins.ubuntu.com/job/build/4797/console
FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/4825/console

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

review: Needs Fixing (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-04-03

642. By Nick Dedekind on 2017-04-03: merged with parent

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-04-03:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-04-04

643. By Nick Dedekind on 2017-04-04: reduce external WindowManagementPolicy API

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-04-04:

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

review: Approve (continuous-integration)

lp:~unity-team/qtmir/qtmir.api updated on 2017-04-05

644. By Nick Dedekind on 2017-04-05: fixed miral include file

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-04-05:

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

review: Approve (continuous-integration)

Unmerged revisions

644. By Nick Dedekind on 2017-04-05: fixed miral include file
643. By Nick Dedekind on 2017-04-04: reduce external WindowManagementPolicy API
642. By Nick Dedekind on 2017-04-03: merged with parent
641. By Nick Dedekind on 2017-03-24: added build dir to cmake path
640. By Nick Dedekind on 2017-03-24: merged parent
639. By Nick Dedekind on 2017-03-21: consistency
638. By Nick Dedekind on 2017-03-21: review comments
637. By Nick Dedekind on 2017-03-20: removed appnotifier and window notifier
636. By Nick Dedekind on 2017-03-20: merged with parent
635. By Nick Dedekind on 2017-03-16: merged with parent

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mir development team

Unity Team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2017-03-24 11:29:56 +0000
 +++ CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -3,9 +3,11 @@
  project(qtmir)
  set(QTMIR_VERSION_MAJOR 0)
--set(QTMIR_VERSION_MINOR 2)
++set(QTMIR_VERSION_MINOR 6)
  set(QTMIR_VERSION_PATCH 0)
++set(QTMIR_VERSION ${QTMIR_VERSION_MAJOR}.${QTMIR_VERSION_MINOR}.${QTMIR_VERSION_PATCH})
++
  if(${PROJECT_BINARY_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
     message(FATAL_ERROR "In-tree build attempt detected, aborting. Set your build dir outside your source dir, delete CMakeCache.txt and CMakeFiles/ from source root and try again.")
  endif()
 === modified file 'debian/changelog'
 --- debian/changelog	2017-03-28 17:14:50 +0000
 +++ debian/changelog	2017-04-05 10:39:22 +0000
@@ -1,3 +1,10 @@
++qtmir (0.6.0) UNRELEASED; urgency=medium
++
++  [ Nick Dedekind ]
++  * Introduced QtMir API
++
++ -- Nick Dedekind <nick.dedekind@canonical.com>  Fri, 10 Feb 2017 09:09:09 +0000
++
  qtmir (0.5.1+17.04.20170328-0ubuntu1) zesty; urgency=medium
    [ Alan Griffiths ]
 === modified file 'debian/control'
 --- debian/control	2017-03-24 11:29:56 +0000
 +++ debian/control	2017-04-05 10:39:22 +0000
@@ -91,6 +91,35 @@
+  .
   This variant of the package is for GNU-based desktops.
++Package: libqtmirserver-dev
++Section: libdevel
++Architecture: any
++Multi-Arch: same
++Pre-Depends: ${misc:Pre-Depends}
++Depends: qtmir-desktop (= ${binary:Version}) | qtmir-android (= ${binary:Version}),
++         ${misc:Depends},
++         libmiral-dev (>= 1.3.0),
++Description: Developer files for QtMir server API
++ QtMir is a set of Qt5 components to enable one to write a Mir server with Qt.
++ It contains a QPA (Qt Platform Abstraction) plugin which creates and manages
++ a Mir server. It also exposes some internal Mir functionality.
++ .
++ This package contains the library headers for developers.
++
++Package: libqtmirserver1
++Section: libs
++Architecture: linux-any
++Multi-Arch: same
++Pre-Depends: ${misc:Pre-Depends}
++Depends: ${misc:Depends},
++      ${shlibs:Depends},
++Description: QtMir server API shared library
++ QtMir is a set of Qt5 components to enable one to write a Mir server with Qt.
++ It contains a QPA (Qt Platform Abstraction) plugin which creates and manages
++ a Mir server. It also exposes some internal Mir functionality.
++ .
++ Contains the shared library containing QtMir server API.
++
  Package: qtdeclarative5-qtmir-plugin
  Architecture: any
  Multi-Arch: same
 === modified file 'debian/gles-patches/convert-to-gles.patch'
 --- debian/gles-patches/convert-to-gles.patch	2017-03-07 14:10:10 +0000
 +++ debian/gles-patches/convert-to-gles.patch	2017-04-05 10:39:22 +0000
@@ -1,15 +1,15 @@
--Index: inline-gles-quilt/debian/control
++Index: qtmir.api/debian/control
  ===================================================================
----- inline-gles-quilt.orig/debian/control
--+++ inline-gles-quilt/debian/control
++--- qtmir.api.orig/debian/control
+++++ qtmir.api/debian/control
@@ -1,4 +1,4 @@
  -Source: qtmir
  +Source: qtmir-gles
   Section: libs
   Priority: optional
   Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
--@@ -16,7 +16,13 @@ Build-Depends: cmake,
--                libmirserver-dev (>= 0.24.0),
++@@ -19,7 +19,13 @@ Build-Depends: cmake,
++                libmirserver-dev (>= 0.26.0),
                  libmtdev-dev,
                  libprocess-cpp-dev,
  +               libqt5gui5-gles,
@@ -21,8 +21,8 @@
  +               libqt5test5,
                  libqtdbusmock1-dev (>= 0.2),
                  libqtdbustest1-dev (>= 0.2),
--                libubuntu-app-launch2-dev,
--@@ -31,8 +37,8 @@ Build-Depends: cmake,
++                libubuntu-app-launch3-dev,
++@@ -35,8 +41,8 @@ Build-Depends: cmake,
   # lttng-gen-ts needs python3, but doesn't depend on it itself: bug 1359147
                  python3:any,
                  qt5-default,
@@ -33,7 +33,7 @@
                  qtdeclarative5-dev,
                  qtdeclarative5-private-dev,
                  quilt,
--@@ -45,7 +51,7 @@ Vcs-Bzr: lp:qtmir
++@@ -54,7 +60,7 @@ Vcs-Bzr: lp:qtmir
   Vcs-Browser: http://bazaar.launchpad.net/~mir-team/qtmir/trunk/files
   Package: qtmir-android
@@ -42,7 +42,7 @@
   Multi-Arch: same
   Conflicts: libqtmir,
              qtmir-desktop,
--@@ -56,65 +62,10 @@ Replaces: libqtmir,
++@@ -65,30 +71,13 @@ Replaces: libqtmir,
   Provides: qtmir,
   Depends: ${misc:Depends},
            ${shlibs:Depends},
@@ -71,7 +71,15 @@
  - a Mir server. It also exposes some internal Mir functionality.
  - .
  - This variant of the package is for GNU-based desktops.
---
+++ This variant of the package is for Android-based phones and tablets (built
+++ against the OpenGLES variant of qtbase).
++
++ Package: libqtmirserver-dev
++ Section: libdevel
++@@ -118,40 +107,3 @@ Description: QtMir server API shared lib
++  .
++  Contains the shared library containing QtMir server API.
++
  -Package: qtdeclarative5-qtmir-plugin
  -Architecture: any
  -Multi-Arch: same
@@ -109,20 +117,18 @@
  -Description: QtMir tests and demos
  - This package provides benchmark tests and a simple shell and client using the
  - QtMir QPA.
--+ This variant of the package is for Android-based phones and tablets (built
--+ against the OpenGLES variant of qtbase).
--Index: inline-gles-quilt/debian/rules
++Index: qtmir.api/debian/rules
  ===================================================================
----- inline-gles-quilt.orig/debian/rules
--+++ inline-gles-quilt/debian/rules
--@@ -3,66 +3,31 @@
++--- qtmir.api.orig/debian/rules
+++++ qtmir.api/debian/rules
++@@ -3,68 +3,34 @@
   export DPKG_GENSYMBOLS_CHECK_LEVEL=4
  -include /usr/share/dpkg/default.mk
+ -
   ANDROID_DIR = build-android
---DESKTOP_DIR = build-desktop
++ DESKTOP_DIR = build-desktop
   TMP1_DIR = $(CURDIR)/debian/tmp1
  -TMP2_DIR = $(CURDIR)/debian/tmp2
+ -
@@ -183,3 +189,7 @@
  -	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-desktop
  -	dh_install --sourcedir=$(TMP2_DIR) -pqtdeclarative5-qtmir-plugin
  -	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-tests
++-	dh_install --sourcedir=$(TMP2_DIR) -plibqtmirserver1
++-	dh_install --sourcedir=$(TMP2_DIR) -plibqtmirserver-dev
+++	dh_install --sourcedir=$(TMP1_DIR) -plibqtmirserver1
+++	dh_install --sourcedir=$(TMP1_DIR) -plibqtmirserver-dev
 === added file 'debian/libqtmirserver-dev.install'
 --- debian/libqtmirserver-dev.install	1970-01-01 00:00:00 +0000
 +++ debian/libqtmirserver-dev.install	2017-04-05 10:39:22 +0000
@@ -0,0 +1,3 @@
++usr/include/qtmir
++usr/lib/*/pkgconfig/qtmirserver.pc
++usr/lib/*/libqtmirserver.so
 === added file 'debian/libqtmirserver1.install'
 --- debian/libqtmirserver1.install	1970-01-01 00:00:00 +0000
 +++ debian/libqtmirserver1.install	2017-04-05 10:39:22 +0000
@@ -0,0 +1,1 @@
++usr/lib/*/libqtmirserver.so.1
 === modified file 'debian/qtmir-tests.install'
 --- debian/qtmir-tests.install	2015-10-27 15:56:28 +0000
 +++ debian/qtmir-tests.install	2017-04-05 10:39:22 +0000
@@ -3,4 +3,4 @@
  usr/share/applications/qtmir-demo-client.desktop
  usr/share/qtmir/benchmarks/*
  usr/share/qtmir/qtmir-demo-client/*
--usr/share/qtmir/qtmir-demo-shell/
++usr/share/qtmir/qtmir-demo-shell/*
 === modified file 'debian/rules'
 --- debian/rules	2016-11-23 19:46:24 +0000
 +++ debian/rules	2017-04-05 10:39:22 +0000
@@ -66,3 +66,5 @@
  	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-desktop
  	dh_install --sourcedir=$(TMP2_DIR) -pqtdeclarative5-qtmir-plugin
  	dh_install --sourcedir=$(TMP2_DIR) -pqtmir-tests
++	dh_install --sourcedir=$(TMP2_DIR) -plibqtmirserver1
++	dh_install --sourcedir=$(TMP2_DIR) -plibqtmirserver-dev
 === modified file 'demos/CMakeLists.txt'
 --- demos/CMakeLists.txt	2015-09-01 16:16:47 +0000
 +++ demos/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -1,4 +1,4 @@
  configure_file(paths.h.in ${CMAKE_CURRENT_BINARY_DIR}/paths.h @ONLY)
  add_subdirectory(qml-demo-client)
--add_subdirectory(qml-demo-shell)
 \ No newline at end of file
++add_subdirectory(qml-demo-shell)
 === modified file 'demos/qml-demo-client/main.cpp'
 --- demos/qml-demo-client/main.cpp	2015-09-17 11:20:00 +0000
 +++ demos/qml-demo-client/main.cpp	2017-04-05 10:39:22 +0000
@@ -57,8 +57,8 @@
      view->setResizeMode(QQuickView::SizeRootObjectToView);
      view->setColor("black");
      view->setTitle("Demo Client");
--
--    QUrl source(::qmlDirectory() + "qtmir-demo-client/qml-demo-client.qml");
++
++    QUrl source(::qmlDirectory() + "qml-demo-client/qml-demo-client.qml");
      view->setSource(source);
      QObject::connect(view->engine(), SIGNAL(quit()), application, SLOT(quit()));
 === modified file 'demos/qml-demo-shell/CMakeLists.txt'
 --- demos/qml-demo-shell/CMakeLists.txt	2016-11-07 18:26:47 +0000
 +++ demos/qml-demo-shell/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -2,6 +2,12 @@
  include_directories(
      SYSTEM
++
++    ${CMAKE_SOURCE_DIR}/include
++
++    ${MIRSERVER_INCLUDE_DIRS}
++    ${MIRAL_INCLUDE_DIRS}
++
      ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
      ${Qt5Qml_PRIVATE_INCLUDE_DIRS}
      ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
@@ -14,6 +20,9 @@
  target_link_libraries(
      ${DEMO_SHELL}
++
++    qtmirserver
++
      Qt5::Core
      Qt5::DBus
      Qt5::Qml
 === modified file 'demos/qml-demo-shell/main.cpp'
 --- demos/qml-demo-shell/main.cpp	2016-11-03 20:17:46 +0000
 +++ demos/qml-demo-shell/main.cpp	2017-04-05 10:39:22 +0000
@@ -22,27 +22,100 @@
  #include <QDebug>
  #include <libintl.h>
  #include "../paths.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.
++#include <qtmir/mirserverapplication.h>
++#include <qtmir/displayconfigurationpolicy.h>
++#include <qtmir/sessionauthorizer.h>
++#include <qtmir/windowmanagementpolicy.h>
++#include <qtmir/displayconfigurationstorage.h>
++
++struct DemoDisplayConfigurationPolicy : qtmir::DisplayConfigurationPolicy
++{
++    void apply_to(mir::graphics::DisplayConfiguration& conf)
++    {
++        qDebug() << "OVERRIDE qtmir::DisplayConfigurationPolicy::apply_to";
++        qtmir::DisplayConfigurationPolicy::apply_to(conf);
++    }
++};
++
++class DemoWindowManagementPolicy : public qtmir::WindowManagementPolicy
++{
++public:
++    DemoWindowManagementPolicy(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd)
++        : qtmir::WindowManagementPolicy(tools, dd)
++    {}
++
++    bool handle_keyboard_event(const MirKeyboardEvent *event) override
++    {
++        qDebug() << "OVERRIDE qtmir::WindowManagementPolicy::handle_keyboard_event" << event;
++        return qtmir::WindowManagementPolicy::handle_keyboard_event(event);
++    }
++};
++
++struct DemoDisplayConfigurationStorage : miral::DisplayConfigurationStorage
++{
++    void save(const miral::DisplayId&, const miral::DisplayConfigurationOptions&) override
++    {
++        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::save";
++    }
++
++    bool load(const miral::DisplayId&, miral::DisplayConfigurationOptions&) const override
++    {
++        qDebug() << "OVERRIDE miral::DisplayConfigurationStorage::load";
++        return false;
++    }
++};
++
++struct DemoSessionAuthorizer : qtmir::SessionAuthorizer
++{
++    bool connectionIsAllowed(miral::ApplicationCredentials const& creds) override
++    {
++        qDebug() << "OVERRIDE qtmir::SessionAuthorizer::connectionIsAllowed";
++        return qtmir::SessionAuthorizer::connectionIsAllowed(creds);
++    }
++    bool configureDisplayIsAllowed(miral::ApplicationCredentials const& creds) override
++    {
++        qDebug() << "OVERRIDE qtmir::SessionAuthorizer::configureDisplayIsAllowed";
++        return qtmir::SessionAuthorizer::configureDisplayIsAllowed(creds);
++    }
++    bool setBaseDisplayConfigurationIsAllowed(miral::ApplicationCredentials const& creds) override
++    {
++        qDebug() << "OVERRIDE qtmir::SessionAuthorizer::setBaseDisplayConfigurationIsAllowed";
++        return qtmir::SessionAuthorizer::setBaseDisplayConfigurationIsAllowed(creds);
++    }
++    bool screencastIsAllowed(miral::ApplicationCredentials const& creds) override
++    {
++        qDebug() << "OVERRIDE qtmir::SessionAuthorizer::screencastIsAllowed";
++        return qtmir::SessionAuthorizer::screencastIsAllowed(creds);
++    }
++    bool promptSessionIsAllowed(miral::ApplicationCredentials const& creds) override
++    {
++        qDebug() << "OVERRIDE qtmir::SessionAuthorizer::promptSessionIsAllowed";
++        return qtmir::SessionAuthorizer::promptSessionIsAllowed(creds);
++    }
++};
  int main(int argc, const char *argv[])
+ {
++    qtmir::SetSessionAuthorizer<DemoSessionAuthorizer> sessionAuth;
++    qtmir::SetDisplayConfigurationPolicy<DemoDisplayConfigurationPolicy> displayConfig;
++    qtmir::SetWindowManagementPolicy<DemoWindowManagementPolicy> wmPolicy;
++
++    qtmir::SetDisplayConfigurationStorage<DemoDisplayConfigurationStorage> displayStorage;
++
      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);
++
++    qtmir::MirServerApplication::setApplicationName("api-demo-shell");
++    qtmir::MirServerApplication *application;
++
++    application = new qtmir::MirServerApplication(argc, (char**)argv, { displayConfig, sessionAuth, wmPolicy, displayStorage });
      QQuickView* view = new QQuickView();
      view->engine()->addImportPath(::qmlPluginDirectory());
      view->setResizeMode(QQuickView::SizeRootObjectToView);
      view->setColor("lightgray");
      view->setTitle("Demo Shell");
--
++
      qmlRegisterSingletonType<PointerPosition>("Mir.Pointer", 0, 1, "PointerPosition",
          [](QQmlEngine*, QJSEngine*) -> QObject* { return PointerPosition::instance(); });
 === added directory 'include'
 === added directory 'include/qtmir'
 === renamed file 'src/platforms/mirserver/mirdisplayconfigurationpolicy.h' => 'include/qtmir/displayconfigurationpolicy.h'
 --- src/platforms/mirserver/mirdisplayconfigurationpolicy.h	2017-01-05 14:36:10 +0000
 +++ include/qtmir/displayconfigurationpolicy.h	2017-04-05 10:39:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2015-2016 Canonical, Ltd.
++ * 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
@@ -14,19 +14,79 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#ifndef MIRDISPLAYCONFIGURATIONPOLICY_H
--#define MIRDISPLAYCONFIGURATIONPOLICY_H
++#ifndef QTMIR_DISPLAYCONFIGURATIONPOLICY_H
++#define QTMIR_DISPLAYCONFIGURATIONPOLICY_H
++
++//qtmir
++#include "qtmir/miral/display_configuration_policy.h"
++
++// mir
++#include <mir/server.h>
  #include <memory>
--namespace mir { namespace graphics { class DisplayConfigurationPolicy; }}
++class QMirServer;
  namespace qtmir
+ {
--auto wrapDisplayConfigurationPolicy(const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped)
---> std::shared_ptr<mir::graphics::DisplayConfigurationPolicy>;
--}
--
--
--#endif // MIRDISPLAYCONFIGURATIONPOLICY_H
++/*
++    Provides callback for display configuration customization.
++
++    This default policy applies scaling and form factor decisions on the configuration.
++    It can be subclassed/overriden by using the SetDisplayConfigurationPolicy<> initializer.
++
++    usage:
++    struct MyDisplayConfigurationPolicy : qtmir::DisplayConfigurationPolicy
++    {
++        void apply_to(mir::graphics::DisplayConfiguration& conf) override;
++    }
++
++    qtmir::GuiServerApplication app(argc, argv, { SetDisplayConfigurationPolicy<MyDisplayConfigurationPolicy>() });
++ */
++class DisplayConfigurationPolicy : public miral::DisplayConfigurationPolicy
++{
++public:
++    DisplayConfigurationPolicy();
++
++    virtual void apply_to(mir::graphics::DisplayConfiguration& conf) override;
++
++private:
++    struct Private;
++    std::shared_ptr<Private> d;
++};
++
++using DisplayConfigurationPolicyWrapper = std::function<std::shared_ptr<miral::DisplayConfigurationPolicy>()>;
++
++/*
++    Base class for access to set the display configuration policy
++ */
++class BasicSetDisplayConfigurationPolicy
++{
++public:
++    explicit BasicSetDisplayConfigurationPolicy(DisplayConfigurationPolicyWrapper const& builder);
++    ~BasicSetDisplayConfigurationPolicy() = default;
++
++    void operator()(QMirServer& server);
++
++private:
++    struct Self;
++    std::shared_ptr<Self> self;
++};
++
++/*
++    Set the display configuration policy to allow server customization
++ */
++template<typename Policy>
++class SetDisplayConfigurationPolicy : public BasicSetDisplayConfigurationPolicy
++{
++public:
++    template<typename ...Args>
++    explicit SetDisplayConfigurationPolicy(Args const& ...args) :
++        BasicSetDisplayConfigurationPolicy{
++            [&args...]() { return std::make_shared<Policy>(args...); }} {}
++};
++
++} // namespace qtmir
++
++#endif // QTMIR_DISPLAYCONFIGURATIONPOLICY_H
 === added file 'include/qtmir/displayconfigurationstorage.h'
 --- include/qtmir/displayconfigurationstorage.h	1970-01-01 00:00:00 +0000
 +++ include/qtmir/displayconfigurationstorage.h	2017-04-05 10:39:22 +0000
@@ -0,0 +1,61 @@
++/*
++ * Copyright (C) 2017 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 DISPLAYCONFIGURATIONSTORAGE_H
++#define DISPLAYCONFIGURATIONSTORAGE_H
++
++#include "qtmir/miral/display_configuration_storage.h"
++
++#include <functional>
++#include <memory>
++
++class QMirServer;
++
++namespace qtmir
++{
++
++using DisplayConfigurationStorageBuilder = std::function<std::shared_ptr<miral::DisplayConfigurationStorage>()>;
++
++class BasicSetDisplayConfigurationStorage
++{
++public:
++    explicit BasicSetDisplayConfigurationStorage(DisplayConfigurationStorageBuilder const& builder);
++    ~BasicSetDisplayConfigurationStorage() = default;
++
++    void operator()(QMirServer& server);
++    DisplayConfigurationStorageBuilder builder() const;
++
++private:
++    struct Self;
++    std::shared_ptr<Self> self;
++};
++
++/*
++    Set the display configuration policy to allow server customization
++ */
++template<typename Policy>
++class SetDisplayConfigurationStorage : public BasicSetDisplayConfigurationStorage
++{
++public:
++    template<typename ...Args>
++    explicit SetDisplayConfigurationStorage(Args const& ...args) :
++        BasicSetDisplayConfigurationStorage{
++            [&args...]() { return std::make_shared<Policy>(args...); }} {}
++};
++
++}
++
++#endif // DISPLAYCONFIGURATIONSTORAGE_H
 === added directory 'include/qtmir/miral'
 === added file 'include/qtmir/miral/display_configuration_policy.h'
 --- include/qtmir/miral/display_configuration_policy.h	1970-01-01 00:00:00 +0000
 +++ include/qtmir/miral/display_configuration_policy.h	2017-04-05 10:39:22 +0000
@@ -0,0 +1,42 @@
++/*
++ * Copyright © 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 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 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/>.
++ *
++ * Authored by: Nick Dedekind <nick.dedekind@canonical.com>
++ */
++
++#ifndef MIRAL_DISPLAY_CONDIFIGURATION_POLICY_H
++#define MIRAL_DISPLAY_CONDIFIGURATION_POLICY_H
++
++namespace mir { namespace graphics { class DisplayConfiguration; } }
++
++namespace miral
++{
++
++class DisplayConfigurationPolicy
++{
++public:
++    DisplayConfigurationPolicy();
++
++    virtual ~DisplayConfigurationPolicy() = default;
++    DisplayConfigurationPolicy(DisplayConfigurationPolicy const&) = delete;
++    DisplayConfigurationPolicy& operator=(DisplayConfigurationPolicy const&) = delete;
++
++    virtual void apply_to(mir::graphics::DisplayConfiguration& conf) = 0;
++};
++
++} // namespace miral
++
++
++#endif // MIRAL_DISPLAY_CONDIFIGURATION_POLICY_H
 === renamed file 'src/platforms/mirserver/miral/display_configuration_storage.h' => 'include/qtmir/miral/display_configuration_storage.h'
 --- src/platforms/mirserver/miral/display_configuration_storage.h	2017-04-05 10:39:22 +0000
 +++ include/qtmir/miral/display_configuration_storage.h	2017-04-05 10:39:22 +0000
@@ -39,7 +39,12 @@
+ {
      mir::optional_value<bool> used;
      mir::optional_value<uint> clone_output_index;
--    mir::optional_value<mir::geometry::Size> size;
++    struct DisplayMode
++    {
++        mir::geometry::Size size;
++        double refresh_rate{-1};
++    };
++    mir::optional_value<DisplayMode> mode;
      mir::optional_value<MirOrientation> orientation;
      mir::optional_value<MirFormFactor> form_factor;
      mir::optional_value<float> scale;
 === renamed file 'src/platforms/mirserver/miral/edid.h' => 'include/qtmir/miral/edid.h'
 === added file 'include/qtmir/mirserverapplication.h'
 --- include/qtmir/mirserverapplication.h	1970-01-01 00:00:00 +0000
 +++ include/qtmir/mirserverapplication.h	2017-04-05 10:39:22 +0000
@@ -0,0 +1,49 @@
++/*
++ * Copyright (C) 2017 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_MIRSERVERAPPLICATION_H
++#define QTMIR_MIRSERVERAPPLICATION_H
++
++#include <QtGui/QGuiApplication>
++
++// std
++#include <functional>
++
++class QMirServer;
++
++namespace qtmir {
++
++class WindowModelNotifier;
++class AppNotifier;
++
++class MirServerApplication : public QGuiApplication
++{
++    Q_OBJECT
++
++public:
++    explicit MirServerApplication(int &argc,
++                                  char **argv,
++                                  std::initializer_list<std::function<void(QMirServer&)>> options);
++    ~MirServerApplication();
++
++Q_SIGNALS:
++    // invoked by screen model
++    void screenAboutToBeRemoved(QScreen *screen);
++};
++
++} // namespace qtmir
++
++#endif // QTMIR_MIRSERVERAPPLICATION_H
 === renamed file 'src/platforms/mirserver/sessionauthorizer.h' => 'include/qtmir/sessionauthorizer.h'
 --- src/platforms/mirserver/sessionauthorizer.h	2016-11-03 20:17:46 +0000
 +++ include/qtmir/sessionauthorizer.h	2017-04-05 10:39:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013-2015 Canonical, Ltd.
++ * 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
@@ -14,38 +14,81 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#ifndef SESSIONAUTHORIZER_H
--#define SESSIONAUTHORIZER_H
++#ifndef QTMIR_SESSIONAUTHORIZER_H
++#define QTMIR_SESSIONAUTHORIZER_H
--//std
--#include <string>
++// Qt
++#include <QObject>
  // mir
  #include <miral/application_authorizer.h>
--// Qt
--#include <QObject>
--
--class SessionAuthorizer : public QObject, public miral::ApplicationAuthorizer
++class QMirServer;
++
++namespace qtmir {
++
++/*
++    Provides callbacks to grant/deny access for session capabilities
++ */
++class SessionAuthorizer : public QObject
+ {
      Q_OBJECT
--
  public:
--    SessionAuthorizer(QObject *parent = 0);
++    SessionAuthorizer();
      ~SessionAuthorizer();
--    bool connection_is_allowed(miral::ApplicationCredentials const& creds) override;
--    bool configure_display_is_allowed(miral::ApplicationCredentials const& creds) override;
--    bool set_base_display_configuration_is_allowed(miral::ApplicationCredentials const& creds) override;
--    bool screencast_is_allowed(miral::ApplicationCredentials const& creds) override;
--    bool prompt_session_is_allowed(miral::ApplicationCredentials const& creds) override;
++    virtual bool connectionIsAllowed(miral::ApplicationCredentials const& creds);
++    virtual bool configureDisplayIsAllowed(miral::ApplicationCredentials const& creds);
++    virtual bool setBaseDisplayConfigurationIsAllowed(miral::ApplicationCredentials const& creds);
++    virtual bool screencastIsAllowed(miral::ApplicationCredentials const& creds);
++    virtual bool promptSessionIsAllowed(miral::ApplicationCredentials const& creds);
  Q_SIGNALS:
      // needs to be blocked queued signal which returns value for authorized
      void requestAuthorizationForSession(const pid_t &pid, bool &authorized);
  private:
--    bool m_connectionChecked;
--};
--
--#endif // SESSIONAUTHORIZER_H
++    struct Private;
++    std::shared_ptr<Private> d;
++};
++
++using SessionAuthorizerBuilder =
++    std::function<std::shared_ptr<SessionAuthorizer>()>;
++
++class BasicSetSessionAuthorizer
++{
++public:
++    explicit BasicSetSessionAuthorizer(SessionAuthorizerBuilder const& builder);
++    ~BasicSetSessionAuthorizer() = default;
++
++    void operator()(QMirServer& server);
++    SessionAuthorizerBuilder builder() const;
++
++private:
++    struct Private;
++    std::shared_ptr<Private> d;
++};
++
++/*
++    Set the session authorizer to allow server customization
++
++    usage:
++    class MySessionAuthorizer : publi qtmir::SessionAuthorizer
++    {
++    ...
++    }
++
++    qtmir::GuiServerApplication app(argc, argv, { SetSessionAuthorizer<MySessionAuthorizer>() });
++ */
++template<typename Policy>
++class SetSessionAuthorizer : public BasicSetSessionAuthorizer
++{
++public:
++    template<typename ...Args>
++    explicit SetSessionAuthorizer(Args const& ...args) :
++        BasicSetSessionAuthorizer{[&args...]() { return std::make_shared<Policy>(args...); }} {}
++};
++
++} // namespace qtmir
++
++#endif // QTMIR_SESSIONAUTHORIZER_H
 === added file 'include/qtmir/windowmanagementpolicy.h'
 --- include/qtmir/windowmanagementpolicy.h	1970-01-01 00:00:00 +0000
 +++ include/qtmir/windowmanagementpolicy.h	2017-04-05 10:39:22 +0000
@@ -0,0 +1,129 @@
++/*
++ * Copyright (C) 2017 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_WINDOWMANAGEMENTPOLICY_H
++#define QTMIR_WINDOWMANAGEMENTPOLICY_H
++
++// miral
++#include "miral/canonical_window_manager.h"
++#include <miral/version.h>
++#if MIRAL_VERSION > MIR_VERSION_NUMBER(1,3,1)
++#include <miral/set_window_management_policy.h>
++#else
++#include <miral/set_window_managment_policy.h>
++#endif
++
++// Unity API
++#include <unity/shell/application/Mir.h>
++
++using namespace mir::geometry;
++
++class QMirServer;
++class QMargins;
++
++namespace qtmir {
++
++class WindowModelNotifier;
++class AppNotifier;
++class WindowManagementPolicyPrivate;
++
++/*
++    Provides window management callbacks for window behaviour customization
++ */
++class WindowManagementPolicy : public miral::CanonicalWindowManagerPolicy
++{
++public:
++
++    // From miral::WindowManagementPolicy
++    auto place_new_window(const miral::ApplicationInfo &app_info,
++                           const miral::WindowSpecification &request_parameters)
++        -> miral::WindowSpecification override;
++
++    void handle_window_ready(miral::WindowInfo &windowInfo) override;
++    void handle_modify_window(
++           :: miral::WindowInfo &windowInfo,
++            const miral::WindowSpecification &modifications) override;
++    void handle_raise_window(miral::WindowInfo &windowInfo) override;
++
++    bool handle_keyboard_event(const MirKeyboardEvent *event) override;
++    bool handle_touch_event(const MirTouchEvent *event) override;
++    bool handle_pointer_event(const MirPointerEvent *event) override;
++
++    void advise_begin() override;
++    void advise_end() override;
++
++    void advise_new_app(miral::ApplicationInfo &application) override;
++    void advise_delete_app(const miral::ApplicationInfo &application) override;
++
++    void advise_new_window(const miral::WindowInfo &windowInfo) override;
++    void advise_focus_lost(const miral::WindowInfo &info) override;
++    void advise_focus_gained(const miral::WindowInfo &info) override;
++    void advise_state_change(const miral::WindowInfo &info, MirWindowState state) override;
++    void advise_move_to(const:: miral::WindowInfo &windowInfo, Point topLeft) override;
++    void advise_resize(const miral::WindowInfo &info, const Size &newSize) override;
++    void advise_delete_window(const miral::WindowInfo &windowInfo) override;
++    void advise_raise(const std::vector<miral::Window> &windows) override;
++
++    Rectangle confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement) override;
++
++protected:
++    WindowManagementPolicy(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd);
++
++    std::shared_ptr<WindowManagementPolicyPrivate> d;
++};
++
++using WindowManagmentPolicyBuilder =
++    std::function<std::shared_ptr<WindowManagementPolicy>(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd)>;
++
++class BasicSetWindowManagementPolicy
++{
++public:
++    explicit BasicSetWindowManagementPolicy(WindowManagmentPolicyBuilder const& builder);
++    ~BasicSetWindowManagementPolicy() = default;
++
++    void operator()(QMirServer& server);
++    WindowManagmentPolicyBuilder builder() const;
++
++private:
++    struct Private;
++    std::shared_ptr<Private> d;
++};
++
++/*
++    Set the window management policy to allow server customization
++
++    usage:
++    class MyWindowManagementPolicy : publi qtmir::WindowManagementPolicy
++    {
++    ...
++    }
++
++    qtmir::GuiServerApplication app(argc, argv, { SetWindowManagementPolicy<MyWindowManagementPolicy>() });
++ */
++template<typename Policy>
++class SetWindowManagementPolicy : public BasicSetWindowManagementPolicy
++{
++public:
++    template<typename ...Args>
++    explicit SetWindowManagementPolicy(Args const& ...args) :
++        BasicSetWindowManagementPolicy{[&args...](const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd) {
++            return std::make_shared<Policy>(tools, dd, args...);
++    }} {}
++};
++
++} // namespace qtmir
++
++#endif // QTMIR_WINDOWMANAGEMENTPOLICY_H
 === modified file 'src/modules/Unity/Application/CMakeLists.txt'
 --- src/modules/Unity/Application/CMakeLists.txt	2017-03-13 16:49:49 +0000
 +++ src/modules/Unity/Application/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -1,6 +1,8 @@
  include_directories(
++    ${CMAKE_SOURCE_DIR}/include
      ${CMAKE_SOURCE_DIR}/src/platforms/mirserver
      ${CMAKE_SOURCE_DIR}/src/common
++    ${CMAKE_CURRENT_BINARY_DIR} # for tracepoints.h
+ )
  include_directories(
@@ -95,7 +97,7 @@
      Qt5::Qml
      Qt5::Quick
--    qpa-mirserver
++    qtmirserver
+ )
  # Generate tracepoints.c and .h from tracepoints.tp
 === modified file 'src/modules/Unity/Application/taskcontroller.cpp'
 --- src/modules/Unity/Application/taskcontroller.cpp	2017-03-22 11:00:48 +0000
 +++ src/modules/Unity/Application/taskcontroller.cpp	2017-04-05 10:39:22 +0000
@@ -25,7 +25,7 @@
  #include "nativeinterface.h"
  #include "promptsessionlistener.h"
  #include "promptsession.h"
--#include "sessionauthorizer.h"
++#include "qtmir/sessionauthorizer.h"
  // common
  #include "appnotifier.h"
 === modified file 'src/modules/Unity/Screens/CMakeLists.txt'
 --- src/modules/Unity/Screens/CMakeLists.txt	2016-11-03 20:17:46 +0000
 +++ src/modules/Unity/Screens/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -22,7 +22,7 @@
  target_link_libraries(
      unityscreensplugin
--    qpa-mirserver
++    qtmirserver
      Qt5::Gui
      Qt5::Qml
 === modified file 'src/platforms/mirserver/CMakeLists.txt'
 --- src/platforms/mirserver/CMakeLists.txt	2017-03-20 21:15:29 +0000
 +++ src/platforms/mirserver/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -1,6 +1,9 @@
  # Qt5PlatformSupport is not available as a cmake module.
  # And also not anymore as pkgconfig module since Qt 5.6.
  #pkg_check_modules(QT5PLATFORM_SUPPORT Qt5PlatformSupport REQUIRED)
++include(FindQt5PlatformSupport)
++
++set(QTMIRSERVER_ABI 1)
  add_subdirectory(miral)
@@ -13,34 +16,29 @@
      add_definitions(-DQGL_DEBUG)
  endif()
--#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -fPIC")
--
--# Dirty hack: The private QtPlatformSupport include dirs are not made available via
--# a cmake module or the pkgconfig file (which only exposes the necessary linker flags)
--# So we generate the paths ourselves from the Qt5Gui private dirs!
--set(QT5_PLATFORMSUPPORT_INCLUDE_DIRS)
--foreach(item ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
--  set(newitem "")
--   string(REGEX REPLACE "QtGui" "QtPlatformSupport" newitem ${item})
--   list(APPEND QT5_PLATFORMSUPPORT_INCLUDE_DIRS ${newitem})
--endforeach(item ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
--
  include_directories(
++    ${CMAKE_SOURCE_DIR}/include
      ${CMAKE_SOURCE_DIR}/src/common
++    ${CMAKE_CURRENT_BINARY_DIR} # for tracepoints.h
+ )
  include_directories(
      SYSTEM
      ${MIRAL_INCLUDE_DIRS}
++    ${MIRCOMMON_INCLUDE_DIRS}
++    ${MIRSERVER_INCLUDE_DIRS}
      ${MIRRENDERERGLDEV_INCLUDE_DIRS}
      ${URL_DISPATCHER_INCLUDE_DIRS}
      ${EGL_INCLUDE_DIRS}
      ${LTTNG_INCLUDE_DIRS}
--    ${QT5PLATFORM_SUPPORT_INCLUDE_DIRS}
++    ${Qt5PlatformSupport_INCLUDE_DIRS}
++
++    ${Qt5Gui_INCLUDE_DIRS}
      ${Qt5Gui_PRIVATE_INCLUDE_DIRS}
--    ${QT5_PLATFORMSUPPORT_INCLUDE_DIRS}
++
++    ${Qt5Quick_INCLUDE_DIRS}
      ${Qt5Quick_PRIVATE_INCLUDE_DIRS}
      ${APPLICATION_API_INCLUDE_DIRS}
@@ -56,16 +54,15 @@
  add_definitions(-DBYTE_ORDER=__BYTE_ORDER)
  # These files will compile without mirserver-dev
--add_library(qpa-mirserver-nomirserver OBJECT
++add_library(qtmirserver-nomirserver OBJECT
      ${CMAKE_SOURCE_DIR}/src/common/timestamp.cpp
      logging.cpp
--    plugin.cpp
      shelluuid.cpp
--    ubuntutheme.cpp
      clipboard.cpp
      mirsingleton.cpp
--    sessionauthorizer.cpp
++    wrappedsessionauthorizer.cpp
      promptsessionlistener.cpp
++    displayconfigurationstorage.cpp
      nativeinterface.cpp
      services.cpp
      windowcontroller.cpp
@@ -79,13 +76,13 @@
  include_directories(SYSTEM ${MIRSERVER_INCLUDE_DIRS})
  # These files will only compile with mirserver-dev
--add_library(qpa-mirserver-mirserver OBJECT
++add_library(qtmirserver-mirserver OBJECT
      openglcontextfactory.cpp openglcontextfactory.h
      mircursorimages.cpp
--    mirdisplayconfigurationpolicy.cpp
      screenscontroller.cpp
      qtcompositor.cpp
--    windowmanagementpolicy.cpp
++    displayconfigurationpolicy.cpp
++    wrappedwindowmanagementpolicy.cpp
      mirserverhooks.cpp mirserverhooks.h
      setqtcompositor.cpp setqtcompositor.h
      eventdispatch.cpp eventdispatch.h
@@ -93,7 +90,7 @@
+ )
  # These files get entangled by automoc so they need to go together. And some depend on mirserver-dev
--set(MIRSERVER_QPA_PLUGIN_SRC
++set(QMIRSERVER_PLUGIN_SRC
      ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
      cursor.cpp
      eventbuilder.cpp
@@ -103,41 +100,106 @@
      screen.cpp
      screenwindow.cpp
      screensmodel.cpp
--    mirserverintegration.cpp
      miropenglcontext.cpp
      offscreensurface.cpp
--    # We need to run moc on these headers
++    inputdeviceobserver.cpp
++    mirserverapplication.cpp
++
++# We need to run moc on these headers
++    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
--    ${CMAKE_SOURCE_DIR}/src/common/appnotifier.h
++
++    ${CMAKE_SOURCE_DIR}/include/qtmir/mirserverapplication.h
++    ${CMAKE_SOURCE_DIR}/include/qtmir/displayconfigurationpolicy.h
++    ${CMAKE_SOURCE_DIR}/include/qtmir/sessionauthorizer.h
++    ${CMAKE_SOURCE_DIR}/include/qtmir/windowmanagementpolicy.h
++    ${CMAKE_SOURCE_DIR}/include/qtmir/displayconfigurationstorage.h
++
      ${CMAKE_SOURCE_DIR}/src/common/windowcontrollerinterface.h
      ${CMAKE_SOURCE_DIR}/src/common/windowmodelnotifier.h
--    inputdeviceobserver.cpp
++    ${CMAKE_SOURCE_DIR}/src/common/appnotifier.h
++)
++
++add_library(qtmirserver SHARED
++    ${QMIRSERVER_PLUGIN_SRC}
++    $<TARGET_OBJECTS:qtmirserver-nomirserver>
++    $<TARGET_OBJECTS:qtmirserver-mirserver>
      $<TARGET_OBJECTS:miral-prototypes>
--# We need to run moc on these headers
--    ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
--)
++)
++
++target_link_libraries(qtmirserver
++    PUBLIC
++        ${MIRAL_LDFLAGS}
++        ${MIRSERVER_LDFLAGS}
++        Qt5::Core
++        Qt5::Gui
++
++    PRIVATE
++        ${URL_DISPATCHER_LDFLAGS}
++        ${EGL_LDFLAGS}
++        ${GL_LIBRARIES}
++        ${LTTNG_LIBRARIES}
++        ${GIO_LDFLAGS}
++        ${FONTCONFIG_LDFLAGS}
++        ${XKBCOMMON_LIBRARIES}
++
++        ${CONTENT_HUB_LIBRARIES}
++
++        Qt5::DBus
++        Qt5::Quick
++        Qt5::Sensors
++        ${Qt5PlatformSupport_LIBRARIES}
++)
++
++set_target_properties(qtmirserver
++  PROPERTIES
++  SOVERSION ${QTMIRSERVER_ABI}
++)
++
++set(LIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}")
++set(INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include/qtmir")
++
++configure_file(${CMAKE_CURRENT_SOURCE_DIR}/qtmirserver.pc.in
++    ${CMAKE_CURRENT_BINARY_DIR}/qtmirserver.pc
++    @ONLY
++)
++
++include(UseLttngGenTp)
++add_lttng_gen_tp(NAME tracepoints)
++
++install(
++  TARGETS qtmirserver
++  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
++  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
++)
++
++install(
++  DIRECTORY ${CMAKE_SOURCE_DIR}/include/qtmir
++  DESTINATION "include/qtmir"
++)
++
++install(
++  FILES ${CMAKE_CURRENT_BINARY_DIR}/qtmirserver.pc
++  DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
++)
++
  add_library(qpa-mirserver SHARED
--    ${MIRSERVER_QPA_PLUGIN_SRC}
--    $<TARGET_OBJECTS:qpa-mirserver-nomirserver>
--    $<TARGET_OBJECTS:qpa-mirserver-mirserver>
++    mirserverintegration.cpp
++    plugin.cpp
++    ubuntutheme.cpp
+ )
--target_link_libraries(
--    qpa-mirserver
--    Qt5PlatformSupport
++target_link_libraries(qpa-mirserver
++PRIVATE
++    qtmirserver
++    ${Qt5PlatformSupport_LIBRARIES}
--    ${MIRAL_LDFLAGS}
      ${MIRSERVER_LDFLAGS}
      ${URL_DISPATCHER_LDFLAGS}
      ${EGL_LDFLAGS}
      ${GL_LIBRARIES}
      ${LTTNG_LIBRARIES}
--
--    ${QT5PLATFORM_SUPPORT_LDFLAGS}
--    # TODO Qt5Platform support LDFLAGS dont provide actual required ldflags...
--    # I found these were needed...perhaps there is some way to query qmake/qconfig?
--    -lfreetype
      ${GIO_LDFLAGS}
      ${FONTCONFIG_LDFLAGS}
      ${XKBCOMMON_LIBRARIES}
@@ -150,7 +212,4 @@
      Qt5::Sensors
+ )
--include(UseLttngGenTp)
--add_lttng_gen_tp(NAME tracepoints)
--
  install(TARGETS qpa-mirserver LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}/qt5/plugins/platforms")
 === renamed file 'src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp' => 'src/platforms/mirserver/displayconfigurationpolicy.cpp'
 --- src/platforms/mirserver/mirdisplayconfigurationpolicy.cpp	2017-01-05 14:36:10 +0000
 +++ src/platforms/mirserver/displayconfigurationpolicy.cpp	2017-04-05 10:39:22 +0000
@@ -14,35 +14,28 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#include "mirdisplayconfigurationpolicy.h"
++// qtmir
++#include "qtmir/displayconfigurationpolicy.h"
++#include "qmirserver.h"
--#include <mir/graphics/display_configuration_policy.h>
++// mir
++#include <mir/geometry/point.h>
  #include <mir/graphics/display_configuration.h>
--#include <mir/geometry/point.h>
--#include <mir/server.h>
  #include <qglobal.h>
  #include <QByteArray>
--namespace mg = mir::graphics;
--
  #define ENV_GRID_UNIT_PX "GRID_UNIT_PX"
  #define DEFAULT_GRID_UNIT_PX 8
--namespace {
--class MirDisplayConfigurationPolicy : public mir::graphics::DisplayConfigurationPolicy
--{
--public:
--    MirDisplayConfigurationPolicy(const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped);
--
--    void apply_to(mir::graphics::DisplayConfiguration &conf) override;
--
--private:
--    const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> m_wrapped;
--    float m_defaultScale;
--};
--
--static float getenvFloat(const char* name, float defaultValue)
++namespace mg = mir::graphics;
++
++namespace qtmir
++{
++namespace
++{
++
++float getenvFloat(const char* name, float defaultValue)
+ {
      QByteArray stringValue = qgetenv(name);
      bool ok;
@@ -50,23 +43,31 @@
      return ok ? value : defaultValue;
+ }
--MirDisplayConfigurationPolicy::MirDisplayConfigurationPolicy(
--        const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped)
--    : m_wrapped(wrapped)
++} // namespace
++
++struct DisplayConfigurationPolicy::Private
+ {
--    float gridUnit = DEFAULT_GRID_UNIT_PX;
--    if (qEnvironmentVariableIsSet(ENV_GRID_UNIT_PX)) {
--        gridUnit = getenvFloat(ENV_GRID_UNIT_PX, DEFAULT_GRID_UNIT_PX);
++    Private()
++    {
++        float gridUnit = DEFAULT_GRID_UNIT_PX;
++        if (qEnvironmentVariableIsSet(ENV_GRID_UNIT_PX)) {
++            gridUnit = getenvFloat(ENV_GRID_UNIT_PX, DEFAULT_GRID_UNIT_PX);
++        }
++        m_defaultScale = gridUnit / DEFAULT_GRID_UNIT_PX;
+     }
--    m_defaultScale = gridUnit / DEFAULT_GRID_UNIT_PX;
++
++    float m_defaultScale;
++};
++
++DisplayConfigurationPolicy::DisplayConfigurationPolicy() :
++    d(new DisplayConfigurationPolicy::Private)
++{
+ }
--void MirDisplayConfigurationPolicy::apply_to(mg::DisplayConfiguration &conf)
++void DisplayConfigurationPolicy::apply_to(mg::DisplayConfiguration& conf)
+ {
      int nextTopLeftPosition = 0;
--    m_wrapped->apply_to(conf);
--
      //TODO: scan through saved configurations and select matching one to apply
      // We want to apply a particular display config policy when connecting an external display
@@ -101,22 +102,35 @@
              if (phoneDetected) {
                  if (screenCount == 1 || output.type == mg::DisplayConfigurationOutputType::lvds) {
                      output.form_factor = mir_form_factor_phone;
--                    output.scale = m_defaultScale;
++                    output.scale = d->m_defaultScale;
                  } else { // screenCount > 1 && output.type != lvds
                      output.form_factor = mir_form_factor_monitor;
                      output.scale = 1;
+                 }
              } else { // desktop
                  output.form_factor = mir_form_factor_monitor;
--                output.scale = m_defaultScale; // probably 1 on desktop anyway.
++                output.scale = d->m_defaultScale; // probably 1 on desktop anyway.
+             }
          });
+ }
--} //namespace
--
--auto qtmir::wrapDisplayConfigurationPolicy(const std::shared_ptr<mg::DisplayConfigurationPolicy>& wrapped)
---> std::shared_ptr<mg::DisplayConfigurationPolicy>
--{
--    return std::make_shared<MirDisplayConfigurationPolicy>(wrapped);
--}
++
++struct BasicSetDisplayConfigurationPolicy::Self
++{
++    Self(DisplayConfigurationPolicyWrapper const& builder) :
++        builder{builder} {}
++
++    DisplayConfigurationPolicyWrapper builder;
++};
++
++BasicSetDisplayConfigurationPolicy::BasicSetDisplayConfigurationPolicy(DisplayConfigurationPolicyWrapper const& builder)
++    : self(std::make_shared<Self>(builder))
++{
++}
++
++void BasicSetDisplayConfigurationPolicy::operator()(QMirServer& server)
++{
++    server.wrapDisplayConfigurationPolicy(self->builder);
++}
++
++} // namespace qtmir
 === added file 'src/platforms/mirserver/displayconfigurationstorage.cpp'
 --- src/platforms/mirserver/displayconfigurationstorage.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/mirserver/displayconfigurationstorage.cpp	2017-04-05 10:39:22 +0000
@@ -0,0 +1,46 @@
++/*
++ * Copyright (C) 2017 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 "qtmir/displayconfigurationpolicy.h"
++#include "qmirserver.h"
++
++namespace qtmir
++{
++
++struct BasicSetDisplayConfigurationStorage::Self
++{
++    Self(DisplayConfigurationStorageBuilder const& builder) :
++        builder{builder} {}
++
++    DisplayConfigurationStorageBuilder builder;
++};
++
++BasicSetDisplayConfigurationStorage::BasicSetDisplayConfigurationStorage(const DisplayConfigurationStorageBuilder &builder) :
++    self(std::make_shared<Self>(builder))
++{
++}
++
++void BasicSetDisplayConfigurationStorage::operator()(QMirServer &server)
++{
++    server.overrideDisplayConfigurationStorage(*this);
++}
++
++DisplayConfigurationStorageBuilder BasicSetDisplayConfigurationStorage::builder() const
++{
++    return self->builder;
++}
++
++} // namespace qtmir
 === modified file 'src/platforms/mirserver/miral/CMakeLists.txt'
 --- src/platforms/mirserver/miral/CMakeLists.txt	2017-04-05 10:39:22 +0000
 +++ src/platforms/mirserver/miral/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -1,8 +1,13 @@
  include_directories(SYSTEM ${MIRSERVER_INCLUDE_DIRS} ${MIRRENDERERGLDEV_INCLUDE_DIRS})
++include_directories(
++    ${CMAKE_SOURCE_DIR}/include
++)
++
  add_library(miral-prototypes OBJECT
--    edid.cpp edid.h
--    display_configuration_storage.h
      persist_display_config.cpp persist_display_config.h
      mirbuffer.cpp mirbuffer.h
++    ${CMAKE_SOURCE_DIR}/include/qtmir/miral/display_configuration_storage.h
++    edid.cpp ${CMAKE_SOURCE_DIR}/include/qtmir/miral/edid.h
++    display_configuration_policy.cpp ${CMAKE_SOURCE_DIR}/include/qtmir/miral/display_configuration_policy.h
+ )
 === added file 'src/platforms/mirserver/miral/display_configuration_policy.cpp'
 --- src/platforms/mirserver/miral/display_configuration_policy.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/mirserver/miral/display_configuration_policy.cpp	2017-04-05 10:39:22 +0000
@@ -0,0 +1,21 @@
++/*
++ * Copyright © 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 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 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/>.
++ *
++ * Authored by: Nick Dedekind <nick.dedekind@canonical.com>
++ */
++
++#include "qtmir/miral/display_configuration_policy.h"
++
++miral::DisplayConfigurationPolicy::DisplayConfigurationPolicy() = default;
 === modified file 'src/platforms/mirserver/miral/edid.cpp'
 --- src/platforms/mirserver/miral/edid.cpp	2017-04-05 10:39:22 +0000
 +++ src/platforms/mirserver/miral/edid.cpp	2017-04-05 10:39:22 +0000
@@ -16,7 +16,7 @@
   * Authored by: Nick Dedekind <nick.dedekind@canonical.com>
   */
--#include "edid.h"
++#include "qtmir/miral/edid.h"
  #include <cstring>
  #include <numeric>
 === modified file 'src/platforms/mirserver/miral/persist_display_config.cpp'
 --- src/platforms/mirserver/miral/persist_display_config.cpp	2017-04-05 10:39:22 +0000
 +++ src/platforms/mirserver/miral/persist_display_config.cpp	2017-04-05 10:39:22 +0000
@@ -17,8 +17,9 @@
   */
  #include "persist_display_config.h"
--#include "display_configuration_storage.h"
--#include "edid.h"
++#include "qtmir/miral/display_configuration_policy.h"
++#include "qtmir/miral/display_configuration_storage.h"
++#include "qtmir/miral/edid.h"
  #include <mir/graphics/display_configuration_policy.h>
  #include <mir/graphics/display_configuration.h>
@@ -26,10 +27,14 @@
  #include <mir/observer_registrar.h>
  #include <mir/server.h>
++// shouldn't really import this
++#include <qglobal.h>
++
  namespace mg = mir::graphics;
  namespace
+ {
++
  struct PersistDisplayConfigPolicy
+ {
      PersistDisplayConfigPolicy(std::shared_ptr<miral::DisplayConfigurationStorage> const& storage) :
@@ -38,27 +43,45 @@
      PersistDisplayConfigPolicy(PersistDisplayConfigPolicy const&) = delete;
      auto operator=(PersistDisplayConfigPolicy const&) -> PersistDisplayConfigPolicy& = delete;
--    void apply_to(mg::DisplayConfiguration& conf, mg::DisplayConfigurationPolicy& default_policy);
++    void apply_to(mg::DisplayConfiguration& conf,
++                  miral::DisplayConfigurationPolicy& wrapped_policy,
++                  miral::DisplayConfigurationPolicy& custom_policy);
      void save_config(mg::DisplayConfiguration const& base_conf);
      std::shared_ptr<miral::DisplayConfigurationStorage> storage;
  };
++struct MiralWrappedMirDisplayConfigurationPolicy : miral::DisplayConfigurationPolicy
++{
++    MiralWrappedMirDisplayConfigurationPolicy(std::shared_ptr<mg::DisplayConfigurationPolicy> const& self) :
++        self{self}
++    {}
++
++    void apply_to(mg::DisplayConfiguration& conf) override
++    {
++        self->apply_to(conf);
++    }
++
++    std::shared_ptr<mg::DisplayConfigurationPolicy> self;
++};
++
  struct DisplayConfigurationPolicyAdapter : mg::DisplayConfigurationPolicy
+ {
      DisplayConfigurationPolicyAdapter(
          std::shared_ptr<PersistDisplayConfigPolicy> const& self,
--        std::shared_ptr<mg::DisplayConfigurationPolicy> const& wrapped) :
--        self{self}, default_policy{wrapped}
++            std::shared_ptr<miral::DisplayConfigurationPolicy> const& wrapped_policy,
++            std::shared_ptr<miral::DisplayConfigurationPolicy> const& custom_policy) :
++        self{self}, wrapped_policy{wrapped_policy}, custom_policy{custom_policy}
      {}
      void apply_to(mg::DisplayConfiguration& conf) override
+     {
--        self->apply_to(conf, *default_policy);
++        self->apply_to(conf, *wrapped_policy, *custom_policy);
+     }
      std::shared_ptr<PersistDisplayConfigPolicy> const self;
--    std::shared_ptr<mg::DisplayConfigurationPolicy> const default_policy;
++    std::shared_ptr<miral::DisplayConfigurationPolicy> const wrapped_policy;
++    std::shared_ptr<miral::DisplayConfigurationPolicy> const custom_policy;
  };
  struct DisplayConfigurationObserver : mg::DisplayConfigurationObserver
@@ -75,19 +98,27 @@
          std::shared_ptr<mg::DisplayConfiguration const> const& /*failed_fallback*/,
          std::exception const& /*error*/) override {}
  };
++
++miral::DisplayConfigurationOptions::DisplayMode current_mode_of(mg::DisplayConfigurationOutput const& output)
++{
++    miral::DisplayConfigurationOptions::DisplayMode mode;
++    if (output.current_mode_index >= output.modes.size()) return mode;
++
++    auto const& current_mode = output.modes[output.current_mode_index];
++    mode.size = current_mode.size;
++    mode.refresh_rate = current_mode.vrefresh_hz;
++    return mode;
++}
+ }
  struct miral::PersistDisplayConfig::Self : PersistDisplayConfigPolicy, DisplayConfigurationObserver
+ {
--    Self(std::shared_ptr<DisplayConfigurationStorage> const& storage) :
--        PersistDisplayConfigPolicy(storage) {}
      Self(std::shared_ptr<DisplayConfigurationStorage> const& storage,
           DisplayConfigurationPolicyWrapper const& custom_wrapper) :
          PersistDisplayConfigPolicy(storage),
          custom_wrapper{custom_wrapper} {}
--    DisplayConfigurationPolicyWrapper const custom_wrapper =
--        [](const std::shared_ptr<mg::DisplayConfigurationPolicy> &wrapped) { return wrapped; };
++    DisplayConfigurationPolicyWrapper const custom_wrapper;
      void base_configuration_updated(std::shared_ptr<mg::DisplayConfiguration const> const& base_config) override
+     {
@@ -99,11 +130,6 @@
      void session_configuration_removed(std::shared_ptr<mir::frontend::Session> const&)  {}
  };
--miral::PersistDisplayConfig::PersistDisplayConfig(std::shared_ptr<DisplayConfigurationStorage> const& storage) :
--    self{std::make_shared<Self>(storage)}
--{
--}
--
  miral::PersistDisplayConfig::PersistDisplayConfig(std::shared_ptr<DisplayConfigurationStorage> const& storage,
                                                    DisplayConfigurationPolicyWrapper const& custom_wrapper) :
      self{std::make_shared<Self>(storage, custom_wrapper)}
@@ -122,7 +148,10 @@
          [this](std::shared_ptr<mg::DisplayConfigurationPolicy> const& wrapped)
          -> std::shared_ptr<mg::DisplayConfigurationPolicy>
+         {
--            return std::make_shared<DisplayConfigurationPolicyAdapter>(self, self->custom_wrapper(wrapped));
++            auto custom_wrapper = self->custom_wrapper();
++            return std::make_shared<DisplayConfigurationPolicyAdapter>(self,
++                                                                       std::make_shared<MiralWrappedMirDisplayConfigurationPolicy>(wrapped),
++                                                                       custom_wrapper);
          });
      server.add_init_callback([this, &server]
@@ -131,9 +160,13 @@
  void PersistDisplayConfigPolicy::apply_to(
      mg::DisplayConfiguration& conf,
--    mg::DisplayConfigurationPolicy& default_policy)
++    miral::DisplayConfigurationPolicy& wrapped_policy,
++    miral::DisplayConfigurationPolicy& custom_policy)
+ {
--    default_policy.apply_to(conf);
++    // first apply the policy we wrapped by setting a custom policy
++    wrapped_policy.apply_to(conf);
++    // then apply the custom policy
++    custom_policy.apply_to(conf);
      if (!storage) {
          throw std::runtime_error("No display configuration storage supplied.");
@@ -154,12 +187,14 @@
              miral::DisplayConfigurationOptions config;
              if (storage->load(display_id, config)) {
--                if (config.size.is_set()) {
++                if (config.mode.is_set()) {
                      int mode_index = output.current_mode_index;
                      int i = 0;
                      // Find the mode index which supports the saved size.
                      for (auto iter = output.modes.cbegin(); iter != output.modes.cend(); ++iter, i++) {
--                        if ((*iter).size == config.size.value()) {
++                        auto const& mode = *iter;
++                        auto const& newMode = config.mode.value();
++                        if (mode.size == newMode.size && qFuzzyCompare(mode.vrefresh_hz, newMode.refresh_rate)) {
                              mode_index = i;
                              break;
+                         }
@@ -209,7 +244,7 @@
                  output_index++;
              });
--            config.size = output.extents().size;
++            config.mode = current_mode_of(output);
              config.form_factor = output.form_factor;
              config.orientation = output.orientation;
              config.scale = output.scale;
 === modified file 'src/platforms/mirserver/miral/persist_display_config.h'
 --- src/platforms/mirserver/miral/persist_display_config.h	2017-04-05 10:39:22 +0000
 +++ src/platforms/mirserver/miral/persist_display_config.h	2017-04-05 10:39:22 +0000
@@ -22,25 +22,24 @@
  #include <functional>
  #include <memory>
--namespace mir { class Server; namespace graphics { class DisplayConfigurationPolicy; }}
++namespace mir { class Server; }
  // Prototyping namespace for later incorporation in MirAL
  namespace miral
+ {
++class DisplayConfigurationPolicy;
  class DisplayConfigurationStorage;
  /// Restores the saved display configuration and saves changes to the base configuration
  class PersistDisplayConfig
+ {
  public:
--    PersistDisplayConfig(std::shared_ptr<DisplayConfigurationStorage> const& storage);
      ~PersistDisplayConfig();
      PersistDisplayConfig(PersistDisplayConfig const&);
      auto operator=(PersistDisplayConfig const&) -> PersistDisplayConfig&;
      // TODO factor this out better
--    using DisplayConfigurationPolicyWrapper =
--        std::function<std::shared_ptr<mir::graphics::DisplayConfigurationPolicy>(const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped)>;
++    using DisplayConfigurationPolicyWrapper = std::function<std::shared_ptr<DisplayConfigurationPolicy>()>;
      PersistDisplayConfig(std::shared_ptr<DisplayConfigurationStorage> const& storage,
                           DisplayConfigurationPolicyWrapper const& custom_wrapper);
 === added file 'src/platforms/mirserver/mirserverapplication.cpp'
 --- src/platforms/mirserver/mirserverapplication.cpp	1970-01-01 00:00:00 +0000
 +++ src/platforms/mirserver/mirserverapplication.cpp	2017-04-05 10:39:22 +0000
@@ -0,0 +1,53 @@
++/*
++ * 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 "qtmir/mirserverapplication.h"
++#include "qmirserver.h"
++
++#include <QDebug>
++
++namespace qtmir {
++
++namespace {
++
++QSharedPointer<QMirServer> mirServer;
++
++void init(std::initializer_list<std::function<void(QMirServer&)>> const& options)
++{
++    setenv("QT_QPA_PLATFORM", "mirserver", 1 /* overwrite */);
++
++    mirServer = QMirServer::create();
++    for (auto& option : options) {
++        option(*mirServer.data());
++    }
++}
++
++} // namespace
++
++MirServerApplication::MirServerApplication(int &argc,
++                                           char **argv,
++                                           std::initializer_list<std::function<void(QMirServer&)>> options)
++    : QGuiApplication((init(options), argc), argv) // comma operator to ensure init called before QGuiApplication
++{
++    Q_UNUSED(options);
++}
++
++MirServerApplication::~MirServerApplication()
++{
++    mirServer.clear();
++}
++
++} // qtmir
 === modified file 'src/platforms/mirserver/mirserverintegration.cpp'
 --- src/platforms/mirserver/mirserverintegration.cpp	2017-02-21 18:53:48 +0000
 +++ src/platforms/mirserver/mirserverintegration.cpp	2017-04-05 10:39:22 +0000
@@ -54,7 +54,7 @@
      : m_accessibility(new QPlatformAccessibility())
      , m_fontDb(new QGenericUnixFontDatabase())
      , m_services(new Services)
--    , m_mirServer(new QMirServer)
++    , m_mirServer(QMirServer::create())
      , m_nativeInterface(nullptr)
+ {
      // For access to sensors, qtmir uses qtubuntu-sensors. qtubuntu-sensors reads the
 === modified file 'src/platforms/mirserver/mirserverintegration.h'
 --- src/platforms/mirserver/mirserverintegration.h	2017-02-21 18:53:48 +0000
 +++ src/platforms/mirserver/mirserverintegration.h	2017-04-05 10:39:22 +0000
@@ -20,6 +20,7 @@
  // qt
  #include <qpa/qplatformintegration.h>
  #include <QScopedPointer>
++#include <QSharedPointer>
  class NativeInterface;
  class QMirServer;
@@ -59,7 +60,7 @@
      QScopedPointer<QPlatformFontDatabase> m_fontDb;
      QScopedPointer<QPlatformServices> m_services;
--    QScopedPointer<QMirServer> m_mirServer;
++    QSharedPointer<QMirServer> m_mirServer;
      NativeInterface *m_nativeInterface;
      QPlatformInputContext* m_inputContext;
 === modified file 'src/platforms/mirserver/qmirserver.cpp'
 --- src/platforms/mirserver/qmirserver.cpp	2017-03-14 13:49:38 +0000
 +++ src/platforms/mirserver/qmirserver.cpp	2017-04-05 10:39:22 +0000
@@ -41,10 +41,25 @@
      stop();
+ }
++QSharedPointer<QMirServer> QMirServer::create()
++{
++    static QWeakPointer<QMirServer> server;
++    if (server.isNull()) {
++        QSharedPointer<QMirServer> newServer(new QMirServer());
++        server = newServer.toWeakRef();
++        return newServer;
++    }
++    return server.toStrongRef();
++}
++
  void QMirServer::start()
+ {
      Q_D(QMirServer);
++    if (d->serverThread->isRunning()) {
++        return;
++    }
++
      d->serverThread->start(QThread::TimeCriticalPriority);
      if (!d->serverThread->waitForMirStartup())
@@ -114,3 +129,39 @@
      Q_D(const QMirServer);
      return d->promptSessionManager();
+ }
++
++qtmir::WindowModelNotifier *QMirServer::windowModelNotifier() const
++{
++    Q_D(const QMirServer);
++    return d->windowModelNotifier();
++}
++
++qtmir::AppNotifier *QMirServer::appNotifier() const
++{
++    Q_D(const QMirServer);
++    return d->appNotifier();
++}
++
++void QMirServer::wrapDisplayConfigurationPolicy(qtmir::DisplayConfigurationPolicyWrapper const& setDisplayConfigurationPolicy)
++{
++    Q_D(QMirServer);
++    d->m_displayConfigurationPolicy = setDisplayConfigurationPolicy;
++}
++
++void QMirServer::overrideSessionAuthorizer(qtmir::SessionAuthorizerBuilder const& setApplicationAuthorizer)
++{
++    Q_D(QMirServer);
++    d->m_wrappedSessionAuthorizer = miral::SetApplicationAuthorizer<WrappedSessionAuthorizer>(setApplicationAuthorizer);
++}
++
++void QMirServer::overrideWindowManagementPolicy(const qtmir::WindowManagmentPolicyBuilder &wmPolicyCreator)
++{
++    Q_D(QMirServer);
++    d->m_windowManagementPolicy = wmPolicyCreator;
++}
++
++void QMirServer::overrideDisplayConfigurationStorage(const qtmir::BasicSetDisplayConfigurationStorage &setDisplayConfigStorage)
++{
++    Q_D(QMirServer);
++    d->m_displayConfigurationStorage = setDisplayConfigStorage;
++}
 === modified file 'src/platforms/mirserver/qmirserver.h'
 --- src/platforms/mirserver/qmirserver.h	2017-02-21 18:53:48 +0000
 +++ src/platforms/mirserver/qmirserver.h	2017-04-05 10:39:22 +0000
@@ -19,12 +19,23 @@
  // Qt
  #include <QObject>
--#include <QWeakPointer>
++#include <QSharedPointer>
  #include <memory>
++// local
++#include "qtmir/sessionauthorizer.h"
++#include "qtmir/windowmanagementpolicy.h"
++#include "qtmir/displayconfigurationpolicy.h"
++#include "qtmir/displayconfigurationstorage.h"
++
  // qtmir
--namespace qtmir { class PromptSessionManager; }
++namespace qtmir {
++    class PromptSessionManager;
++    class WindowModelNotifier;
++    class AppNotifier;
++}
++namespace mir { class Server; }
  class QMirServerPrivate;
  class ScreensController;
@@ -37,9 +48,10 @@
      Q_OBJECT
  public:
--    QMirServer(QObject *parent = nullptr);
      virtual ~QMirServer();
++    static QSharedPointer<QMirServer> create();
++
      void start();
      Q_SLOT void stop();
      bool isRunning() const;
@@ -49,6 +61,14 @@
      void *nativeResourceForIntegration(const QByteArray &resource) const;
      std::shared_ptr<qtmir::PromptSessionManager> thePromptSessionManager() const;
++    qtmir::WindowModelNotifier *windowModelNotifier() const;
++    qtmir::AppNotifier *appNotifier() const;
++
++    void wrapDisplayConfigurationPolicy(qtmir::DisplayConfigurationPolicyWrapper const& setDisplayConfigurationPolicy);
++    void overrideSessionAuthorizer(qtmir::SessionAuthorizerBuilder const& setApplicationAuthorizer);
++    void overrideWindowManagementPolicy(qtmir::WindowManagmentPolicyBuilder const& wmPolicyCreator);
++    void overrideDisplayConfigurationStorage(qtmir::BasicSetDisplayConfigurationStorage const& setDisplayConfigStorage);
++
  Q_SIGNALS:
      void started();
      void stopped();
@@ -57,6 +77,7 @@
      QMirServerPrivate * const d_ptr;
  private:
++    QMirServer(QObject *parent = nullptr);
      Q_DISABLE_COPY(QMirServer)
      Q_DECLARE_PRIVATE(QMirServer)
  };
 === modified file 'src/platforms/mirserver/qmirserver_p.cpp'
 --- src/platforms/mirserver/qmirserver_p.cpp	2017-04-05 10:39:22 +0000
 +++ src/platforms/mirserver/qmirserver_p.cpp	2017-04-05 10:39:22 +0000
@@ -15,14 +15,15 @@
   */
  #include "qmirserver_p.h"
--#include "miral/display_configuration_storage.h"
++#include "qtmir/miral/display_configuration_storage.h"
  // local
  #include "logging.h"
--#include "mirdisplayconfigurationpolicy.h"
--#include "windowmanagementpolicy.h"
++#include "wrappedwindowmanagementpolicy.h"
  #include "promptsessionmanager.h"
  #include "setqtcompositor.h"
++#include "qteventfeeder.h"
++#include "qtmir/sessionauthorizer.h"
  // prototyping for later incorporation in miral
  #include <miral/persist_display_config.h>
@@ -30,12 +31,6 @@
  // miral
  #include <miral/add_init_callback.h>
  #include <miral/set_terminator.h>
--#include <miral/version.h>
--#if MIRAL_VERSION > MIR_VERSION_NUMBER(1,3,1)
--#include <miral/set_window_management_policy.h>
--#else
--#include <miral/set_window_managment_policy.h>
--#endif
  // Qt
  #include <QCoreApplication>
@@ -48,12 +43,42 @@
  static int qtmirArgc{1};
  static const char *qtmirArgv[]{"qtmir"};
++class DefaultWindowManagementPolicy : public qtmir::WindowManagementPolicy
++{
++public:
++    DefaultWindowManagementPolicy(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd)
++        : qtmir::WindowManagementPolicy(tools, dd)
++    {}
++};
++
  struct DefaultDisplayConfigurationStorage : miral::DisplayConfigurationStorage
+ {
      void save(const miral::DisplayId&, const miral::DisplayConfigurationOptions&) override {}
      bool load(const miral::DisplayId&, miral::DisplayConfigurationOptions&) const override { return false; }
  };
++
++std::shared_ptr<miral::DisplayConfigurationPolicy> buildDisplayConfigurationPolicy()
++{
++    return std::make_shared<qtmir::DisplayConfigurationPolicy>();
++}
++
++std::shared_ptr<miral::DisplayConfigurationStorage> buildDisplayConfigurationStorage()
++{
++    return std::make_shared<DefaultDisplayConfigurationStorage>();
++}
++
++std::shared_ptr<qtmir::WindowManagementPolicy> buildWindowManagementPolicy(const miral::WindowManagerTools &tools,
++                                                                           std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd)
++{
++    return std::make_shared<DefaultWindowManagementPolicy>(tools, dd);
++}
++
++std::shared_ptr<qtmir::SessionAuthorizer> buildSessionAuthorizer()
++{
++    return std::make_shared<qtmir::SessionAuthorizer>();
++}
++
  } // namespace
  void MirServerThread::run()
@@ -89,8 +114,18 @@
      return std::make_shared<qtmir::PromptSessionManager>(m_mirServerHooks.thePromptSessionManager());
+ }
--QMirServerPrivate::QMirServerPrivate() :
--    runner(qtmirArgc, qtmirArgv)
++std::shared_ptr<qtmir::SessionAuthorizer> QMirServerPrivate::theApplicationAuthorizer() const
++{
++    auto wrapped = m_wrappedSessionAuthorizer.the_custom_application_authorizer();
++    return wrapped ? wrapped->wrapper() : nullptr;
++}
++
++QMirServerPrivate::QMirServerPrivate()
++    : m_displayConfigurationPolicy(buildDisplayConfigurationPolicy)
++    , m_windowManagementPolicy(buildWindowManagementPolicy)
++    , m_displayConfigurationStorage(buildDisplayConfigurationStorage)
++    , m_wrappedSessionAuthorizer(buildSessionAuthorizer)
++    , runner(qtmirArgc, qtmirArgv)
+ {
+ }
@@ -139,18 +174,24 @@
          screensController.clear();
      });
++    auto eventFeeder = std::make_shared<QtEventFeeder>(screensModel);
++    auto displayStorageBuilder = m_displayConfigurationStorage.builder();
++
      runner.run_with(
+         {
--            m_sessionAuthorizer,
++            m_wrappedSessionAuthorizer,
              m_openGLContextFactory,
              m_mirServerHooks,
--            miral::set_window_management_policy<WindowManagementPolicy>(m_windowModelNotifier, m_windowController,
--                    m_appNotifier, screensModel),
++            miral::set_window_management_policy<WrappedWindowManagementPolicy>(m_windowModelNotifier,
++                                                                               m_windowController,
++                                                                               m_appNotifier,
++                                                                               eventFeeder,
++                                                                               m_windowManagementPolicy),
              addInitCallback,
              qtmir::SetQtCompositor{screensModel},
              setTerminator,
--            miral::PersistDisplayConfig{std::make_shared<DefaultDisplayConfigurationStorage>(),
--                                        &qtmir::wrapDisplayConfigurationPolicy}
++            miral::PersistDisplayConfig{displayStorageBuilder(),
++                                        m_displayConfigurationPolicy}
          });
+ }
 === modified file 'src/platforms/mirserver/qmirserver_p.h'
 --- src/platforms/mirserver/qmirserver_p.h	2017-02-21 18:53:48 +0000
 +++ src/platforms/mirserver/qmirserver_p.h	2017-04-05 10:39:22 +0000
@@ -31,19 +31,23 @@
  #include "screensmodel.h"
  #include "windowcontroller.h"
  #include "windowmodelnotifier.h"
--#include "sessionauthorizer.h"
  #include "mirserverhooks.h"
++#include "wrappedsessionauthorizer.h"
++#include "qtmir/displayconfigurationpolicy.h"
++#include "qtmir/windowmanagementpolicy.h"
++#include "qtmir/displayconfigurationstorage.h"
  //miral
--#include <miral/application_authorizer.h>
  #include <miral/runner.h>
++#include <QDebug>
  class MirServerThread;
  class QOpenGLContext;
++class QMirServer;
  namespace qtmir
+ {
--using SetSessionAuthorizer = miral::SetApplicationAuthorizer<SessionAuthorizer>;
++class SessionAuthorizer;
  class PromptSessionManager;
+ }
@@ -63,8 +67,7 @@
      PromptSessionListener *promptSessionListener() const;
      std::shared_ptr<qtmir::PromptSessionManager> promptSessionManager() const;
--    std::shared_ptr<SessionAuthorizer> theApplicationAuthorizer() const
--        { return m_sessionAuthorizer.the_custom_application_authorizer(); }
++    std::shared_ptr<qtmir::SessionAuthorizer> theApplicationAuthorizer() const;
      qtmir::WindowModelNotifier *windowModelNotifier() const
          { return &m_windowModelNotifier; }
@@ -75,8 +78,11 @@
      qtmir::WindowControllerInterface *windowController() const
          { return &m_windowController; }
++    qtmir::DisplayConfigurationPolicyWrapper m_displayConfigurationPolicy;
++    qtmir::WindowManagmentPolicyBuilder m_windowManagementPolicy;
++    qtmir::BasicSetDisplayConfigurationStorage m_displayConfigurationStorage;
++    miral::SetApplicationAuthorizer<WrappedSessionAuthorizer> m_wrappedSessionAuthorizer;
  private:
--    qtmir::SetSessionAuthorizer m_sessionAuthorizer;
      qtmir::OpenGLContextFactory m_openGLContextFactory;
      qtmir::MirServerHooks       m_mirServerHooks;
 === added file 'src/platforms/mirserver/qtmirserver.pc.in'
 --- src/platforms/mirserver/qtmirserver.pc.in	1970-01-01 00:00:00 +0000
 +++ src/platforms/mirserver/qtmirserver.pc.in	2017-04-05 10:39:22 +0000
@@ -0,0 +1,9 @@
++libdir=@LIBDIR@
++includedir=@INCLUDEDIR@
++
++Name: qtmirserver
++Description: QtMir server library
++Version: @QTMIR_VERSION@
++Requires: miral >= 1.1
++Libs: -L${libdir} -lqtmirserver
++Cflags: -I${includedir}
 === modified file 'src/platforms/mirserver/screensmodel.cpp'
 --- src/platforms/mirserver/screensmodel.cpp	2017-01-18 18:30:14 +0000
 +++ src/platforms/mirserver/screensmodel.cpp	2017-04-05 10:39:22 +0000
@@ -19,7 +19,6 @@
  #include "screenwindow.h"
  #include "qtcompositor.h"
  #include "logging.h"
--#include "mirserverintegration.h"
  #include "screen.h"
  #include "mirqtconversion.h"
@@ -166,7 +165,7 @@
          if (window && window->window() && window->isExposed()) {
              window->window()->hide();
+         }
--        bool ok = QMetaObject::invokeMethod(qApp, "onScreenAboutToBeRemoved", Qt::DirectConnection, Q_ARG(QScreen*, screen->screen()));
++        bool ok = QMetaObject::invokeMethod(qApp, "screenAboutToBeRemoved", Qt::DirectConnection, Q_ARG(QScreen*, screen->screen()));
          if (!ok) {
              qCWarning(QTMIR_SCREENS) << "Failed to invoke QGuiApplication::onScreenAboutToBeRemoved(QScreen*) slot.";
+         }
 === modified file 'src/platforms/mirserver/windowcontroller.cpp'
 --- src/platforms/mirserver/windowcontroller.cpp	2017-03-16 16:59:09 +0000
 +++ src/platforms/mirserver/windowcontroller.cpp	2017-04-05 10:39:22 +0000
@@ -15,8 +15,8 @@
   */
  #include "windowcontroller.h"
++#include "wrappedwindowmanagementpolicy.h"
--#include "windowmanagementpolicy.h"
  #include "mirqtconversion.h"
  using namespace qtmir;
@@ -111,7 +111,7 @@
+     }
+ }
--void WindowController::setPolicy(WindowManagementPolicy * const policy)
++void WindowController::setPolicy(WrappedWindowManagementPolicy * const policy)
+ {
      m_policy = policy;
+ }
 === modified file 'src/platforms/mirserver/windowcontroller.h'
 --- src/platforms/mirserver/windowcontroller.h	2017-03-21 10:30:57 +0000
 +++ src/platforms/mirserver/windowcontroller.h	2017-04-05 10:39:22 +0000
@@ -19,11 +19,11 @@
  #include "windowcontrollerinterface.h"
--class WindowManagementPolicy;
++class WrappedWindowManagementPolicy;
  namespace qtmir {
--class WindowController : public WindowControllerInterface
++class WindowController : public qtmir::WindowControllerInterface
+ {
  public:
      WindowController();
@@ -46,10 +46,10 @@
      void setWindowConfinementRegions(const QVector<QRect> &regions) override;
      void setWindowMargins(Mir::Type windowType, const QMargins &margins) override;
--    void setPolicy(WindowManagementPolicy *policy);
++    void setPolicy(WrappedWindowManagementPolicy *policy);
  protected:
--    WindowManagementPolicy *m_policy;
++    WrappedWindowManagementPolicy *m_policy;
  };
  } // namespace qtmir
 === renamed file 'src/platforms/mirserver/sessionauthorizer.cpp' => 'src/platforms/mirserver/wrappedsessionauthorizer.cpp'
 --- src/platforms/mirserver/sessionauthorizer.cpp	2017-01-26 14:34:08 +0000
 +++ src/platforms/mirserver/wrappedsessionauthorizer.cpp	2017-04-05 10:39:22 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013-2015 Canonical, Ltd.
++ * 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
@@ -14,81 +14,143 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#include "sessionauthorizer.h"
++#include "wrappedsessionauthorizer.h"
++#include "qmirserver.h"
  #include "logging.h"
  #include "tracepoints.h" // generated from tracepoints.tp
  #include <QMetaMethod>
  #include <QThread>
--SessionAuthorizer::SessionAuthorizer(QObject *parent)
--    : QObject(parent)
--    , m_connectionChecked(false)
--{
--}
--
--SessionAuthorizer::~SessionAuthorizer()
--{
--}
--
--bool SessionAuthorizer::connection_is_allowed(miral::ApplicationCredentials const& creds)
--{
--    tracepoint(qtmirserver, sessionAuthorizeStart);
--    qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::connection_is_allowed - this=" << this << "pid=" << creds.pid();
--    bool authorized = true;
--
--    if (!m_connectionChecked) {
--        // Wait until the ApplicationManager is ready to receive requestAuthorizationForSession signals
--        QMetaMethod mm = QMetaMethod::fromSignal(&SessionAuthorizer::requestAuthorizationForSession);
--        for (int i = 0; i < 100 && !isSignalConnected(mm); ++i) {
--            QThread::usleep(10000);
--        }
--        if (!isSignalConnected(mm)) {
--            qCDebug(QTMIR_MIR_MESSAGES) <<
--                "SessionAuthorizer::connection_is_allowed - Gave up waiting for signal listeners";
--        }
--        m_connectionChecked = true;
--    }
--
--    Q_EMIT requestAuthorizationForSession(creds.pid(), authorized); // needs to block until authorized value returned
--    tracepoint(qtmirserver, sessionAuthorizeEnd);
--
--    return authorized;
--}
--
--bool SessionAuthorizer::configure_display_is_allowed(miral::ApplicationCredentials const& creds)
--{
--    qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::configure_display_is_allowed - this=" << this << "pid=" << creds.pid();
--
--    //FIXME(ricmm) Actually mediate this access for clients
--    Q_UNUSED(creds)
--    return true;
--}
--
--bool SessionAuthorizer::screencast_is_allowed(miral::ApplicationCredentials const& creds)
--{
--    qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::screencast_is_allowed - this=" << this << "pid=" << creds.pid();
--
--    //FIXME Actually mediate this access for clients
--    Q_UNUSED(creds)
--    return true;
--}
--
--bool SessionAuthorizer::prompt_session_is_allowed(miral::ApplicationCredentials const& creds)
--{
--    qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::prompt_session_is_allowed - this=" << this << "pid=" << creds.pid();
--
--    //FIXME Actually mediate this access for clients
--    Q_UNUSED(creds)
--    return true;
--}
--
--bool SessionAuthorizer::set_base_display_configuration_is_allowed(miral::ApplicationCredentials const& creds)
--{
--    qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::set_base_display_configuration_is_allowed - this="
--        << this << "pid=" << creds.pid();
--
--    //FIXME Actually mediate this access for clients
--    Q_UNUSED(creds)
--    return true;
++namespace qtmir {
++
++    struct SessionAuthorizer::Private
++    {
++        bool m_connectionChecked{false};
++    };
++
++    SessionAuthorizer::SessionAuthorizer()
++        : d(new SessionAuthorizer::Private)
++    {
++    }
++
++    SessionAuthorizer::~SessionAuthorizer()
++    {
++    }
++
++    bool SessionAuthorizer::connectionIsAllowed(miral::ApplicationCredentials const& creds)
++    {
++        tracepoint(qtmirserver, sessionAuthorizeStart);
++        qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::connection_is_allowed - this=" << this << "pid=" << creds.pid();
++        bool authorized = true;
++
++        if (!d->m_connectionChecked) {
++            // Wait until the ApplicationManager is ready to receive requestAuthorizationForSession signals
++            QMetaMethod mm = QMetaMethod::fromSignal(&SessionAuthorizer::requestAuthorizationForSession);
++            for (int i = 0; i < 100 && !isSignalConnected(mm); ++i) {
++                QThread::usleep(10000);
++            }
++            if (!isSignalConnected(mm)) {
++                qCDebug(QTMIR_MIR_MESSAGES) <<
++                    "SessionAuthorizer::connection_is_allowed - Gave up waiting for signal listeners";
++            }
++            d->m_connectionChecked = true;
++        }
++
++        Q_EMIT requestAuthorizationForSession(creds.pid(), authorized); // needs to block until authorized value returned
++        tracepoint(qtmirserver, sessionAuthorizeEnd);
++
++        return authorized;
++    }
++
++    bool SessionAuthorizer::configureDisplayIsAllowed(miral::ApplicationCredentials const& creds)
++    {
++        qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::configure_display_is_allowed - this=" << this << "pid=" << creds.pid();
++
++        //FIXME(ricmm) Actually mediate this access for clients
++        Q_UNUSED(creds)
++        return true;
++    }
++
++    bool SessionAuthorizer::setBaseDisplayConfigurationIsAllowed(miral::ApplicationCredentials const& creds)
++    {
++        qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::screencast_is_allowed - this=" << this << "pid=" << creds.pid();
++
++        //FIXME Actually mediate this access for clients
++        Q_UNUSED(creds)
++        return true;
++    }
++
++    bool SessionAuthorizer::screencastIsAllowed(miral::ApplicationCredentials const& creds)
++    {
++        qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::prompt_session_is_allowed - this=" << this << "pid=" << creds.pid();
++
++        //FIXME Actually mediate this access for clients
++        Q_UNUSED(creds)
++        return true;
++    }
++
++    bool SessionAuthorizer::promptSessionIsAllowed(miral::ApplicationCredentials const& creds)
++    {
++        qCDebug(QTMIR_MIR_MESSAGES) << "SessionAuthorizer::set_base_display_configuration_is_allowed - this="
++            << this << "pid=" << creds.pid();
++
++        //FIXME Actually mediate this access for clients
++        Q_UNUSED(creds)
++        return true;
++    }
++
++
++    struct BasicSetSessionAuthorizer::Private
++    {
++        Private(qtmir::SessionAuthorizerBuilder const& builder) :
++            builder{builder} {}
++
++        qtmir::SessionAuthorizerBuilder builder;
++    };
++
++    BasicSetSessionAuthorizer::BasicSetSessionAuthorizer(qtmir::SessionAuthorizerBuilder const& builder)
++        : d(new BasicSetSessionAuthorizer::Private(builder))
++    {
++    }
++
++    void BasicSetSessionAuthorizer::operator()(QMirServer &server)
++    {
++        server.overrideSessionAuthorizer(d->builder);
++    }
++
++    SessionAuthorizerBuilder qtmir::BasicSetSessionAuthorizer::builder() const
++    {
++        return d->builder;
++    }
++}
++
++WrappedSessionAuthorizer::WrappedSessionAuthorizer(const qtmir::SessionAuthorizerBuilder &builder)
++    : impl(builder())
++{
++}
++
++bool WrappedSessionAuthorizer::connection_is_allowed(const miral::ApplicationCredentials &creds)
++{
++    return impl->connectionIsAllowed(creds);
++}
++
++bool WrappedSessionAuthorizer::configure_display_is_allowed(const miral::ApplicationCredentials &creds)
++{
++    return impl->configureDisplayIsAllowed(creds);
++}
++
++bool WrappedSessionAuthorizer::set_base_display_configuration_is_allowed(const miral::ApplicationCredentials &creds)
++{
++    return impl->setBaseDisplayConfigurationIsAllowed(creds);
++}
++
++bool WrappedSessionAuthorizer::screencast_is_allowed(const miral::ApplicationCredentials &creds)
++{
++    return impl->screencastIsAllowed(creds);
++}
++
++bool WrappedSessionAuthorizer::prompt_session_is_allowed(const miral::ApplicationCredentials &creds)
++{
++    return impl->promptSessionIsAllowed(creds);
+ }
 === added file 'src/platforms/mirserver/wrappedsessionauthorizer.h'
 --- src/platforms/mirserver/wrappedsessionauthorizer.h	1970-01-01 00:00:00 +0000
 +++ src/platforms/mirserver/wrappedsessionauthorizer.h	2017-04-05 10:39:22 +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 WRAPPEDSESSIONAUTHORIZER_H
++#define WRAPPEDSESSIONAUTHORIZER_H
++
++#include "qtmir/sessionauthorizer.h"
++
++class WrappedSessionAuthorizer : public miral::ApplicationAuthorizer
++{
++public:
++    WrappedSessionAuthorizer(qtmir::SessionAuthorizerBuilder const& builder);
++
++    virtual bool connection_is_allowed(miral::ApplicationCredentials const& creds) override;
++    virtual bool configure_display_is_allowed(miral::ApplicationCredentials const& creds) override;
++    virtual bool set_base_display_configuration_is_allowed(miral::ApplicationCredentials const& creds) override;
++    virtual bool screencast_is_allowed(miral::ApplicationCredentials const& creds) override;
++    virtual bool prompt_session_is_allowed(miral::ApplicationCredentials const& creds) override;
++
++    std::shared_ptr<qtmir::SessionAuthorizer> wrapper() { return impl; }
++
++private:
++    std::shared_ptr<qtmir::SessionAuthorizer> impl;
++};
++
++#endif // WRAPPEDSESSIONAUTHORIZER_H
 === renamed file 'src/platforms/mirserver/windowmanagementpolicy.cpp' => 'src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp'
 --- src/platforms/mirserver/windowmanagementpolicy.cpp	2017-03-24 11:29:56 +0000
 +++ src/platforms/mirserver/wrappedwindowmanagementpolicy.cpp	2017-04-05 10:39:22 +0000
@@ -14,7 +14,7 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#include "windowmanagementpolicy.h"
++#include "wrappedwindowmanagementpolicy.h"
  #include "eventdispatch.h"
  #include "initialsurfacesizes.h"
@@ -25,26 +25,297 @@
  #include "miral/window_specification.h"
  #include "mirqtconversion.h"
++#include "qmirserver.h"
  #include "tracepoints.h"
--namespace qtmir {
++#include <QDebug>
++
++using namespace mir::geometry;
++
++namespace qtmir
++{
      std::shared_ptr<ExtraWindowInfo> getExtraInfo(const miral::WindowInfo &windowInfo) {
          return std::static_pointer_cast<ExtraWindowInfo>(windowInfo.userdata());
+     }
++
++    struct BasicSetWindowManagementPolicy::Private
++    {
++        Private(WindowManagmentPolicyBuilder const& builder) :
++            builder{builder} {}
++
++        WindowManagmentPolicyBuilder builder;
++    };
++
++    BasicSetWindowManagementPolicy::BasicSetWindowManagementPolicy(WindowManagmentPolicyBuilder const& builder)
++        : d(new BasicSetWindowManagementPolicy::Private(builder))
++    {
++    }
++
++    void BasicSetWindowManagementPolicy::operator()(QMirServer &server)
++    {
++        server.overrideWindowManagementPolicy(d->builder);
++    }
++
++    WindowManagmentPolicyBuilder BasicSetWindowManagementPolicy::builder() const
++    {
++        return d->builder;
++    }
++
++    struct WindowManagementPolicyPrivate
++    {
++        WindowManagementPolicyPrivate(qtmir::WindowModelNotifier &windowModel,
++                                      qtmir::AppNotifier &appNotifier,
++                                      const std::shared_ptr<QtEventFeeder>& eventFeeder)
++            : m_windowModel(windowModel)
++            , m_appNotifier(appNotifier)
++            , m_eventFeeder(eventFeeder)
++        {}
++
++        QRect getConfinementRect(const QRect rect) const
++        {
++            QRect confinementRect;
++            for (const QRect r : m_confinementRegions) {
++                if (r.intersects(rect)) {
++                    confinementRect = r;
++                    // TODO: What if there are multiple confinement regions and they intersect??
++                    break;
++                }
++            }
++            return confinementRect;
++        }
++
++        qtmir::WindowModelNotifier &m_windowModel;
++        qtmir::AppNotifier &m_appNotifier;
++        const std::shared_ptr<QtEventFeeder> m_eventFeeder;
++
++        QVector<QRect> m_confinementRegions;
++        QMargins m_windowMargins[mir_window_types];
++    };
++
++    WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools, std::shared_ptr<qtmir::WindowManagementPolicyPrivate> dd)
++        : miral::CanonicalWindowManagerPolicy(tools)
++        , d(dd)
++    {
++    }
++
++    miral::WindowSpecification WindowManagementPolicy::place_new_window(
++        const miral::ApplicationInfo &appInfo,
++        const miral::WindowSpecification &requestParameters)
++    {
++        auto parameters = CanonicalWindowManagerPolicy::place_new_window(appInfo, requestParameters);
++
++        if (!requestParameters.parent().is_set() || requestParameters.parent().value().lock().get() == nullptr) {
++
++            int surfaceType = requestParameters.type().is_set() ? requestParameters.type().value() : -1;
++
++            QSize initialSize = InitialSurfaceSizes::get(miral::pid_of(appInfo.application()));
++
++            if (initialSize.isValid() && surfaceType == mir_surface_type_normal) {
++                parameters.size() = toMirSize(initialSize);
++            }
++        }
++
++        parameters.userdata() = std::make_shared<ExtraWindowInfo>();
++
++        return parameters;
++    }
++
++    void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
++    {
++        CanonicalWindowManagerPolicy::handle_window_ready(windowInfo);
++
++        Q_EMIT d->m_windowModel.windowReady(windowInfo);
++
++        auto appInfo = tools.info_for(windowInfo.window().application());
++        Q_EMIT d->m_appNotifier.appCreatedWindow(appInfo);
++    }
++
++    void WindowManagementPolicy::handle_modify_window(miral::WindowInfo &windowInfo,
++                                                      const miral::WindowSpecification &modificationsClient)
++    {
++        miral::WindowSpecification modifications(modificationsClient);
++
++        if (modifications.size().is_set()) {
++            auto extraWindowInfo = qtmir::getExtraInfo(windowInfo);
++            QMutexLocker locker(&extraWindowInfo->mutex);
++            if (!extraWindowInfo->allowClientResize) {
++                modifications.size().consume();
++            }
++        }
++
++        CanonicalWindowManagerPolicy::handle_modify_window(windowInfo, modifications);
++
++        // TODO Once Qt processes the request we probably don't want to notify from here
++        std::shared_ptr<mir::scene::Surface> surface{windowInfo.window()};
++        if (SurfaceObserver *observer = SurfaceObserver::observerForSurface(surface.get())) {
++            observer->notifySurfaceModifications(modifications);
++        }
++    }
++
++    void WindowManagementPolicy::handle_raise_window(miral::WindowInfo &windowInfo)
++    {
++        CanonicalWindowManagerPolicy::handle_raise_window(windowInfo);
++
++        Q_EMIT d->m_windowModel.windowRequestedRaise(windowInfo);
++    }
++
++    bool WindowManagementPolicy::handle_keyboard_event(const MirKeyboardEvent *event)
++    {
++        d->m_eventFeeder->dispatchKey(event);
++        return true;
++    }
++
++    bool WindowManagementPolicy::handle_touch_event(const MirTouchEvent *event)
++    {
++        d->m_eventFeeder->dispatchTouch(event);
++        return true;
++    }
++
++    bool WindowManagementPolicy::handle_pointer_event(const MirPointerEvent *event)
++    {
++        d->m_eventFeeder->dispatchPointer(event);
++        return true;
++    }
++
++    void WindowManagementPolicy::advise_begin()
++    {
++        Q_EMIT d->m_windowModel.modificationsStarted();
++    }
++
++    void WindowManagementPolicy::advise_end()
++    {
++        Q_EMIT d->m_windowModel.modificationsEnded();
++    }
++
++    void WindowManagementPolicy::advise_new_app(miral::ApplicationInfo &application)
++    {
++        Q_EMIT d->m_appNotifier.appAdded(application);
++    }
++
++    void WindowManagementPolicy::advise_delete_app(const miral::ApplicationInfo &application)
++    {
++        Q_EMIT d->m_appNotifier.appRemoved(application);
++    }
++
++    void WindowManagementPolicy::advise_new_window(const miral::WindowInfo &windowInfo)
++    {
++        // TODO: attach surface observer here
++
++        getExtraInfo(windowInfo)->persistentId = QString::fromStdString(tools.id_for_window(windowInfo.window()));
++
++        // FIXME: remove when possible
++        getExtraInfo(windowInfo)->state = toQtState(windowInfo.state());
++
++        Q_EMIT d->m_windowModel.windowAdded(NewWindow{windowInfo});
++    }
++
++    void WindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &windowInfo)
++    {
++        Q_EMIT d->m_windowModel.windowFocusChanged(windowInfo, false);
++    }
++
++    void WindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &windowInfo)
++    {
++        // update Qt model ASAP, before applying Mir policy
++        Q_EMIT d->m_windowModel.windowFocusChanged(windowInfo, true);
++
++        CanonicalWindowManagerPolicy::advise_focus_gained(windowInfo);
++    }
++
++    void WindowManagementPolicy::advise_state_change(const miral::WindowInfo &windowInfo, MirWindowState state)
++    {
++        auto extraWinInfo = getExtraInfo(windowInfo);
++
++        // FIXME: Remove this mess once MirWindowState matches Mir::State
++        if (state == mir_window_state_restored && extraWinInfo->state != Mir::RestoredState
++                && toMirState(extraWinInfo->state) == state) {
++            // Ignore. That MirWindowState is just a placeholder for a Mir::State value that has no counterpart
++            // in MirWindowState.
++        } else {
++            extraWinInfo->state = toQtState(state);
++        }
++
++        Q_EMIT d->m_windowModel.windowStateChanged(windowInfo, extraWinInfo->state);
++    }
++
++    void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
++    {
++        Q_EMIT d->m_windowModel.windowMoved(windowInfo, toQPoint(topLeft));
++    }
++
++    void WindowManagementPolicy::advise_resize(const miral::WindowInfo &windowInfo, const Size &newSize)
++    {
++        Q_EMIT d->m_windowModel.windowResized(windowInfo, toQSize(newSize));
++    }
++
++    void WindowManagementPolicy::advise_delete_window(const miral::WindowInfo &windowInfo)
++    {
++        Q_EMIT d->m_windowModel.windowRemoved(windowInfo);
++    }
++
++    void WindowManagementPolicy::advise_raise(const std::vector<miral::Window> &windows)
++    {
++        Q_EMIT d->m_windowModel.windowsRaised(windows);
++    }
++
++    Rectangle WindowManagementPolicy::confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement)
++    {
++        if (d->m_confinementRegions.isEmpty()) {
++            return CanonicalWindowManagerPolicy::confirm_inherited_move(windowInfo, movement);
++        }
++
++        auto window = windowInfo.window();
++        const QMargins windowMargins = d->m_windowMargins[windowInfo.type()];
++        QRect windowGeom(toQPoint(window.top_left()), toQSize(window.size()));
++
++        QRect geom = windowGeom.marginsAdded(windowMargins);
++        const QRect confinementRect = d->getConfinementRect(geom);
++
++        int x = geom.x();
++        int y = geom.y();
++        int moveX = movement.dx.as_int();
++        int moveY = movement.dy.as_int();
++
++        // If the child window is already partially beyond the available desktop area (most likely because the user
++        // explicitly moved it there) we won't pull it back, unless the inherited movement is this direction, but also won't
++        // push it even further astray. But if it currently is completely within the available desktop area boundaries
++        // we won't let go beyond it.
++
++        if (moveX > 0) {
++            if (geom.right() < confinementRect.right()) {
++                x = qMin(x + moveX, confinementRect.right() + 1 - geom.width()); // +1 because QRect::right() weird
++            }
++        } else {
++            if (geom.x() > confinementRect.left()) {
++                x = qMax(x + moveX, confinementRect.left());
++            }
++        }
++
++        if (moveY > 0) {
++            if (geom.bottom() < confinementRect.bottom()) {
++                y = qMin(y + moveY, confinementRect.bottom() + 1 - geom.height()); // +1 because QRect::bottom() weird
++            }
++        } else {
++            if (geom.y() > confinementRect.top()) {
++                y = qMax(y + moveY, confinementRect.top());
++            }
++        }
++
++        geom.moveTo(x, y);
++        return toMirRectangle(geom.marginsRemoved(windowMargins));
++    }
+ }
--using namespace qtmir;
--
--WindowManagementPolicy::WindowManagementPolicy(const miral::WindowManagerTools &tools,
++WrappedWindowManagementPolicy::WrappedWindowManagementPolicy(const miral::WindowManagerTools &tools,
                                                 qtmir::WindowModelNotifier &windowModel,
                                                 qtmir::WindowController &windowController,
                                                 qtmir::AppNotifier &appNotifier,
--                                               const QSharedPointer<ScreensModel> screensModel)
--    : CanonicalWindowManagerPolicy(tools)
--    , m_tools(tools)
--    , m_windowModel(windowModel)
--    , m_appNotifier(appNotifier)
--    , m_eventFeeder(new QtEventFeeder(screensModel))
++                                               const std::shared_ptr<QtEventFeeder> &eventFeeder,
++                                               const qtmir::WindowManagmentPolicyBuilder &wmBuilder)
++    : qtmir::WindowManagementPolicy(tools, std::make_shared<qtmir::WindowManagementPolicyPrivate>(windowModel,
++                                                                                                  appNotifier,
++                                                                                                  eventFeeder))
++    , m_wrapper(wmBuilder(tools, d))
+ {
      qRegisterMetaType<qtmir::NewWindow>();
      qRegisterMetaType<std::vector<miral::Window>>();
@@ -53,256 +324,174 @@
+ }
  /* Following are hooks to allow custom policy be imposed */
--miral::WindowSpecification WindowManagementPolicy::place_new_window(
++miral::WindowSpecification WrappedWindowManagementPolicy::place_new_window(
      const miral::ApplicationInfo &appInfo,
      const miral::WindowSpecification &requestParameters)
+ {
--    auto parameters = CanonicalWindowManagerPolicy::place_new_window(appInfo, requestParameters);
--
--    if (!requestParameters.parent().is_set() || requestParameters.parent().value().lock().get() == nullptr) {
--
--        int surfaceType = requestParameters.type().is_set() ? requestParameters.type().value() : -1;
--
--        QSize initialSize = InitialSurfaceSizes::get(miral::pid_of(appInfo.application()));
--
--        if (initialSize.isValid() && surfaceType == mir_surface_type_normal) {
--            parameters.size() = toMirSize(initialSize);
--        }
--    }
--
--    parameters.userdata() = std::make_shared<ExtraWindowInfo>();
--
--    return parameters;
++    return m_wrapper->place_new_window(appInfo, requestParameters);
+ }
--void WindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
++void WrappedWindowManagementPolicy::handle_window_ready(miral::WindowInfo &windowInfo)
+ {
--    CanonicalWindowManagerPolicy::handle_window_ready(windowInfo);
--
--    Q_EMIT m_windowModel.windowReady(windowInfo);
--
--    auto appInfo = m_tools.info_for(windowInfo.window().application());
--    Q_EMIT m_appNotifier.appCreatedWindow(appInfo);
++    m_wrapper->handle_window_ready(windowInfo);
+ }
--void WindowManagementPolicy::handle_modify_window(
++void WrappedWindowManagementPolicy::handle_modify_window(
      miral::WindowInfo &windowInfo,
      const miral::WindowSpecification &modificationsClient)
+ {
--    miral::WindowSpecification modifications(modificationsClient);
--
--    if (modifications.size().is_set()) {
--        auto extraWindowInfo = getExtraInfo(windowInfo);
--        QMutexLocker locker(&extraWindowInfo->mutex);
--        if (!extraWindowInfo->allowClientResize) {
--            modifications.size().consume();
--        }
--    }
--
--    CanonicalWindowManagerPolicy::handle_modify_window(windowInfo, modifications);
--
--    // TODO Once Qt processes the request we probably don't want to notify from here
--    std::shared_ptr<mir::scene::Surface> surface{windowInfo.window()};
--    if (SurfaceObserver *observer = SurfaceObserver::observerForSurface(surface.get())) {
--        observer->notifySurfaceModifications(modifications);
--    }
++    m_wrapper->handle_modify_window(windowInfo, modificationsClient);
+ }
--void WindowManagementPolicy::handle_raise_window(miral::WindowInfo &windowInfo)
++void WrappedWindowManagementPolicy::handle_raise_window(miral::WindowInfo &windowInfo)
+ {
--    Q_EMIT m_windowModel.windowRequestedRaise(windowInfo);
++    m_wrapper->handle_raise_window(windowInfo);
+ }
  /* Handle input events - here just inject them into Qt event loop for later processing */
--bool WindowManagementPolicy::handle_keyboard_event(const MirKeyboardEvent *event)
--{
--    m_eventFeeder->dispatchKey(event);
--    return true;
--}
--
--bool WindowManagementPolicy::handle_touch_event(const MirTouchEvent *event)
--{
--    m_eventFeeder->dispatchTouch(event);
--    return true;
--}
--
--bool WindowManagementPolicy::handle_pointer_event(const MirPointerEvent *event)
--{
--    m_eventFeeder->dispatchPointer(event);
--    return true;
--}
--
--void WindowManagementPolicy::advise_new_window(const miral::WindowInfo &windowInfo)
--{
--    // TODO: attach surface observer here
--
--    getExtraInfo(windowInfo)->persistentId = QString::fromStdString(m_tools.id_for_window(windowInfo.window()));
--
--    // FIXME: remove when possible
--    getExtraInfo(windowInfo)->state = toQtState(windowInfo.state());
--
--    Q_EMIT m_windowModel.windowAdded(NewWindow{windowInfo});
--}
--
--void WindowManagementPolicy::advise_delete_window(const miral::WindowInfo &windowInfo)
--{
--    Q_EMIT m_windowModel.windowRemoved(windowInfo);
--}
--
--void WindowManagementPolicy::advise_raise(const std::vector<miral::Window> &windows)
--{
--    Q_EMIT m_windowModel.windowsRaised(windows);
--}
--
--void WindowManagementPolicy::advise_new_app(miral::ApplicationInfo &application)
--{
--    tracepoint(qtmirserver, starting);
--    Q_EMIT m_appNotifier.appAdded(application);
--}
--
--void WindowManagementPolicy::advise_delete_app(const miral::ApplicationInfo &application)
--{
--    tracepoint(qtmirserver, stopping);
--    Q_EMIT m_appNotifier.appRemoved(application);
--}
--
--void WindowManagementPolicy::advise_state_change(const miral::WindowInfo &windowInfo, MirWindowState state)
--{
--    auto extraWinInfo = getExtraInfo(windowInfo);
--
--    // FIXME: Remove this mess once MirWindowState matches Mir::State
--    if (state == mir_window_state_restored && extraWinInfo->state != Mir::RestoredState
--            && toMirState(extraWinInfo->state) == state) {
--        // Ignore. That MirWindowState is just a placeholder for a Mir::State value that has no counterpart
--        // in MirWindowState.
--    } else {
--        extraWinInfo->state = toQtState(state);
--    }
--
--    Q_EMIT m_windowModel.windowStateChanged(windowInfo, extraWinInfo->state);
--}
--
--void WindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
--{
--    Q_EMIT m_windowModel.windowMoved(windowInfo, toQPoint(topLeft));
--}
--
--void WindowManagementPolicy::advise_resize(const miral::WindowInfo &windowInfo, const Size &newSize)
--{
--    Q_EMIT m_windowModel.windowResized(windowInfo, toQSize(newSize));
--}
--
--void WindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &windowInfo)
--{
--    Q_EMIT m_windowModel.windowFocusChanged(windowInfo, false);
--}
--
--void WindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &windowInfo)
--{
--    // update Qt model ASAP, before applying Mir policy
--    Q_EMIT m_windowModel.windowFocusChanged(windowInfo, true);
--
--    CanonicalWindowManagerPolicy::advise_focus_gained(windowInfo);
--}
--
--void WindowManagementPolicy::advise_begin()
--{
--    Q_EMIT m_windowModel.modificationsStarted();
--}
--
--void WindowManagementPolicy::advise_end()
--{
--    Q_EMIT m_windowModel.modificationsEnded();
--}
--
--void WindowManagementPolicy::ensureWindowIsActive(const miral::Window &window)
--{
--    m_tools.invoke_under_lock([&window, this]() {
--        if (m_tools.active_window() != window) {
--            m_tools.select_active_window(window);
--        }
--    });
--}
--
--QRect WindowManagementPolicy::getConfinementRect(const QRect rect) const
--{
--    QRect confinementRect;
--    for (const QRect r : m_confinementRegions) {
--        if (r.intersects(rect)) {
--            confinementRect = r;
--            // TODO: What if there are multiple confinement regions and they intersect??
--            break;
--        }
--    }
--    return confinementRect;
--}
--
--/* Following methods all called from the Qt GUI thread to deliver events to clients */
--void WindowManagementPolicy::deliver_keyboard_event(const MirKeyboardEvent *event,
--                                                    const miral::Window &window)
++bool WrappedWindowManagementPolicy::handle_keyboard_event(const MirKeyboardEvent *event)
++{
++    return m_wrapper->handle_keyboard_event(event);
++}
++
++bool WrappedWindowManagementPolicy::handle_touch_event(const MirTouchEvent *event)
++{
++    return m_wrapper->handle_touch_event(event);
++}
++
++bool WrappedWindowManagementPolicy::handle_pointer_event(const MirPointerEvent *event)
++{
++    return m_wrapper->handle_pointer_event(event);
++}
++
++void WrappedWindowManagementPolicy::advise_begin()
++{
++    m_wrapper->advise_begin();
++}
++
++void WrappedWindowManagementPolicy::advise_end()
++{
++    m_wrapper->advise_end();
++}
++
++void WrappedWindowManagementPolicy::advise_new_window(const miral::WindowInfo &windowInfo)
++{
++    m_wrapper->advise_new_window(windowInfo);
++}
++
++void WrappedWindowManagementPolicy::advise_delete_window(const miral::WindowInfo &windowInfo)
++{
++    m_wrapper->advise_delete_window(windowInfo);
++}
++
++void WrappedWindowManagementPolicy::advise_raise(const std::vector<miral::Window> &windows)
++{
++    m_wrapper->advise_raise(windows);
++}
++
++Rectangle WrappedWindowManagementPolicy::confirm_inherited_move(const miral::WindowInfo &windowInfo, Displacement movement)
++{
++    return m_wrapper->confirm_inherited_move(windowInfo, movement);
++}
++
++void WrappedWindowManagementPolicy::advise_new_app(miral::ApplicationInfo &application)
++{
++    m_wrapper->advise_new_app(application);
++}
++
++void WrappedWindowManagementPolicy::advise_delete_app(const miral::ApplicationInfo &application)
++{
++    m_wrapper->advise_delete_app(application);
++}
++
++void WrappedWindowManagementPolicy::advise_focus_lost(const miral::WindowInfo &info)
++{
++    m_wrapper->advise_focus_lost(info);
++}
++
++void WrappedWindowManagementPolicy::advise_focus_gained(const miral::WindowInfo &info)
++{
++    m_wrapper->advise_focus_gained(info);
++}
++
++void WrappedWindowManagementPolicy::advise_state_change(const miral::WindowInfo &info, MirWindowState state)
++{
++    m_wrapper->advise_state_change(info, state);
++}
++
++void WrappedWindowManagementPolicy::advise_move_to(const miral::WindowInfo &windowInfo, Point topLeft)
++{
++    m_wrapper->advise_move_to(windowInfo, topLeft);
++}
++
++void WrappedWindowManagementPolicy::advise_resize(const miral::WindowInfo &info, const Size &newSize)
++{
++    m_wrapper->advise_resize(info, newSize);
++}
++
++void WrappedWindowManagementPolicy::deliver_keyboard_event(const MirKeyboardEvent *event, const miral::Window &window)
+ {
      if (mir_keyboard_event_action(event) == mir_keyboard_action_down) {
--        ensureWindowIsActive(window);
++        tools.invoke_under_lock([&]() {
++            if (tools.active_window() != window) {
++                tools.select_active_window(window);
++            }
++        });
+     }
--    dispatchInputEvent(window, mir_keyboard_event_input_event(event));
++    qtmir::dispatchInputEvent(window, mir_keyboard_event_input_event(event));
+ }
--void WindowManagementPolicy::deliver_touch_event(const MirTouchEvent *event,
--                                                 const miral::Window &window)
++void WrappedWindowManagementPolicy::deliver_touch_event(const MirTouchEvent *event, const miral::Window &window)
+ {
--    ensureWindowIsActive(window);
++    tools.invoke_under_lock([&]() {
++        if (tools.active_window() != window) {
++            tools.select_active_window(window);
++        }
++    });
--    dispatchInputEvent(window, mir_touch_event_input_event(event));
++    qtmir::dispatchInputEvent(window, mir_touch_event_input_event(event));
+ }
--void WindowManagementPolicy::deliver_pointer_event(const MirPointerEvent *event,
--                                                   const miral::Window &window)
++void WrappedWindowManagementPolicy::deliver_pointer_event(const MirPointerEvent *event, const miral::Window &window)
+ {
      // Prevent mouse hover events causing window focus to change
      if (mir_pointer_event_action(event) == mir_pointer_action_button_down) {
--        ensureWindowIsActive(window);
++        tools.invoke_under_lock([&]() {
++            if (tools.active_window() != window) {
++                tools.select_active_window(window);
++            }
++        });
+     }
--    dispatchInputEvent(window, mir_pointer_event_input_event(event));
++    qtmir::dispatchInputEvent(window, mir_pointer_event_input_event(event));
+ }
--/* Methods to allow Shell to request changes to the window stack. Called from the Qt GUI thread */
--
--// raises the window tree and focus it.
--void WindowManagementPolicy::activate(const miral::Window &window)
++void WrappedWindowManagementPolicy::activate(const miral::Window &window)
+ {
      if (window) {
--        auto &windowInfo = m_tools.info_for(window);
++        auto &windowInfo = tools.info_for(window);
          // restore from minimized if needed
          if (windowInfo.state() == mir_window_state_minimized) {
--            auto extraInfo = getExtraInfo(windowInfo);
++            auto extraInfo = qtmir::getExtraInfo(windowInfo);
              Q_ASSERT(extraInfo->previousState != Mir::MinimizedState);
              requestState(window, extraInfo->previousState);
+         }
+     }
--    m_tools.invoke_under_lock([&]() {
--        m_tools.select_active_window(window);
--    });
--}
--
--// raises the window tree
--void WindowManagementPolicy::raise(const miral::Window &window)
--{
--    m_tools.invoke_under_lock([&window, this]() {
--        m_tools.raise_tree(window);
--    });
--}
--
--void WindowManagementPolicy::resize(const miral::Window &window, const Size size)
++    tools.invoke_under_lock([&]() {
++        tools.select_active_window(window);
++    });
++}
++
++void WrappedWindowManagementPolicy::resize(const miral::Window &window, const Size size)
+ {
      miral::WindowSpecification modifications;
      modifications.size() = size;
--    m_tools.invoke_under_lock([&window, &modifications, this]() {
++    tools.invoke_under_lock([&window, &modifications, this]() {
          try {
--            m_tools.modify_window(m_tools.info_for(window), modifications);
++            tools.modify_window(tools.info_for(window), modifications);
          } catch (const std::out_of_range&) {
              // usually shell trying to operate on a window which already closed, just ignore
              // TODO: MirSurface extends the miral::Window lifetime by holding a shared pointer to
@@ -312,13 +501,13 @@
      });
+ }
--void WindowManagementPolicy::move(const miral::Window &window, const Point topLeft)
++void WrappedWindowManagementPolicy::move(const miral::Window &window, const Point topLeft)
+ {
      miral::WindowSpecification modifications;
      modifications.top_left() = topLeft;
--    m_tools.invoke_under_lock([&window, &modifications, this]() {
++    tools.invoke_under_lock([&window, &modifications, this]() {
          try {
--            m_tools.modify_window(m_tools.info_for(window), modifications);
++            tools.modify_window(tools.info_for(window), modifications);
          } catch (const std::out_of_range&) {
              // usually shell trying to operate on a window which already closed, just ignore
              // TODO: see above comment in resize, same issue
@@ -326,44 +515,23 @@
      });
+ }
--void WindowManagementPolicy::ask_client_to_close(const miral::Window &window)
--{
--    m_tools.invoke_under_lock([&window, this]() {
--        m_tools.ask_client_to_close(window);
--    });
--}
--
--void WindowManagementPolicy::forceClose(const miral::Window &window)
--{
--    m_tools.invoke_under_lock([&window, this]() {
--        m_tools.force_close(window);
--    });
--}
--
--void WindowManagementPolicy::set_window_confinement_regions(const QVector<QRect> &regions)
--{
--    m_confinementRegions = regions;
--
--    // TODO: update window positions to respect new boundary.
--}
--
--void WindowManagementPolicy::set_window_margins(MirWindowType windowType, const QMargins &margins)
--{
--    m_windowMargins[windowType] = margins;
--
--    // TODO: update window positions/sizes to respect new margins.
--}
--
--void WindowManagementPolicy::requestState(const miral::Window &window, const Mir::State state)
--{
--    auto &windowInfo = m_tools.info_for(window);
--    auto extraWinInfo = getExtraInfo(windowInfo);
++void WrappedWindowManagementPolicy::raise(const miral::Window &window)
++{
++    tools.invoke_under_lock([&window, this]() {
++        tools.raise_tree(window);
++    });
++}
++
++void WrappedWindowManagementPolicy::requestState(const miral::Window &window, const Mir::State state)
++{
++    auto &windowInfo = tools.info_for(window);
++    auto extraWinInfo = qtmir::getExtraInfo(windowInfo);
      if (extraWinInfo->state == state)
          return;
      miral::WindowSpecification modifications;
--    modifications.state() = toMirState(state);
++    modifications.state() = qtmir::toMirState(state);
      // TODO: What if the window modification fails? Is that possible?
      //       Assuming here that the state will indeed change
@@ -371,57 +539,38 @@
      extraWinInfo->state = state;
      if (modifications.state() == windowInfo.state()) {
--        Q_EMIT m_windowModel.windowStateChanged(windowInfo, state);
++        Q_EMIT d->m_windowModel.windowStateChanged(windowInfo, state);
      } else {
--        m_tools.invoke_under_lock([&]() {
--            m_tools.modify_window(windowInfo, modifications);
++        tools.invoke_under_lock([&]() {
++            tools.modify_window(windowInfo, modifications);
          });
+     }
+ }
--Rectangle WindowManagementPolicy::confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement)
--{
--    if (m_confinementRegions.isEmpty()) {
--        return CanonicalWindowManagerPolicy::confirm_inherited_move(windowInfo, movement);
--    }
--
--    auto window = windowInfo.window();
--    const QMargins windowMargins = m_windowMargins[windowInfo.type()];
--    QRect windowGeom(toQPoint(window.top_left()), toQSize(window.size()));
--
--    QRect geom = windowGeom.marginsAdded(windowMargins);
--    const QRect confinementRect = getConfinementRect(geom);
--
--    int x = geom.x();
--    int y = geom.y();
--    int moveX = movement.dx.as_int();
--    int moveY = movement.dy.as_int();
--
--    // If the child window is already partially beyond the available desktop area (most likely because the user
--    // explicitly moved it there) we won't pull it back, unless the inherited movement is this direction, but also won't
--    // push it even further astray. But if it currently is completely within the available desktop area boundaries
--    // we won't let go beyond it.
--
--    if (moveX > 0) {
--        if (geom.right() < confinementRect.right()) {
--            x = qMin(x + moveX, confinementRect.right() + 1 - geom.width()); // +1 because QRect::right() weird
--        }
--    } else {
--        if (geom.x() > confinementRect.left()) {
--            x = qMax(x + moveX, confinementRect.left());
--        }
--    }
--
--    if (moveY > 0) {
--        if (geom.bottom() < confinementRect.bottom()) {
--            y = qMin(y + moveY, confinementRect.bottom() + 1 - geom.height()); // +1 because QRect::bottom() weird
--        }
--    } else {
--        if (geom.y() > confinementRect.top()) {
--            y = qMax(y + moveY, confinementRect.top());
--        }
--    }
--
--    geom.moveTo(x, y);
--    return toMirRectangle(geom.marginsRemoved(windowMargins));
++void WrappedWindowManagementPolicy::ask_client_to_close(const miral::Window &window)
++{
++    tools.invoke_under_lock([&window, this]() {
++        tools.ask_client_to_close(window);
++    });
++}
++
++void WrappedWindowManagementPolicy::forceClose(const miral::Window &window)
++{
++    tools.invoke_under_lock([&window, this]() {
++        tools.force_close(window);
++    });
++}
++
++void WrappedWindowManagementPolicy::set_window_confinement_regions(const QVector<QRect> &regions)
++{
++    d->m_confinementRegions = regions;
++
++    // TODO: update window positions to respect new boundary.
++}
++
++void WrappedWindowManagementPolicy::set_window_margins(MirWindowType windowType, const QMargins &margins)
++{
++    d->m_windowMargins[windowType] = margins;
++
++    // TODO: update window positions/sizes to respect new margins.
+ }
 === renamed file 'src/platforms/mirserver/windowmanagementpolicy.h' => 'src/platforms/mirserver/wrappedwindowmanagementpolicy.h'
 --- src/platforms/mirserver/windowmanagementpolicy.h	2017-03-22 14:04:23 +0000
 +++ src/platforms/mirserver/wrappedwindowmanagementpolicy.h	2017-04-05 10:39:22 +0000
@@ -14,30 +14,30 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
--#ifndef WINDOWMANAGEMENTPOLICY_H
--#define WINDOWMANAGEMENTPOLICY_H
--
--#include "miral/canonical_window_manager.h"
++#ifndef WRAPPEDWINDOWMANAGEMENTPOLICY_H
++#define WRAPPEDWINDOWMANAGEMENTPOLICY_H
  #include "appnotifier.h"
  #include "qteventfeeder.h"
  #include "windowcontroller.h"
  #include "windowmodelnotifier.h"
++#include "qtmir/windowmanagementpolicy.h"
  #include <QScopedPointer>
  using namespace mir::geometry;
--class ScreensModel;
++class QtEventFeeder;
--class WindowManagementPolicy : public miral::CanonicalWindowManagerPolicy
++class WrappedWindowManagementPolicy : public qtmir::WindowManagementPolicy
+ {
  public:
--    WindowManagementPolicy(const miral::WindowManagerTools &tools,
--                           qtmir::WindowModelNotifier &windowModel,
--                           qtmir::WindowController &windowController,
--                           qtmir::AppNotifier &appNotifier,
--                           const QSharedPointer<ScreensModel> screensModel);
++    WrappedWindowManagementPolicy(const miral::WindowManagerTools &tools,
++                                  qtmir::WindowModelNotifier &windowModel,
++                                  qtmir::WindowController &windowController,
++                                  qtmir::AppNotifier &appNotifier,
++                                  const std::shared_ptr<QtEventFeeder> &eventFeeder,
++                                  const qtmir::WindowManagmentPolicyBuilder &wmBuilder);
      // From WindowManagementPolicy
      auto place_new_window(const miral::ApplicationInfo &app_info,
@@ -71,7 +71,6 @@
      Rectangle confirm_inherited_move(miral::WindowInfo const& windowInfo, Displacement movement) override;
--
      // Methods for consumption by WindowControllerInterface
      void deliver_keyboard_event(const MirKeyboardEvent *event, const miral::Window &window);
      void deliver_touch_event   (const MirTouchEvent *event,    const miral::Window &window);
@@ -90,15 +89,7 @@
      void set_window_margins(MirWindowType windowType, const QMargins &margins);
  private:
--    void ensureWindowIsActive(const miral::Window &window);
--    QRect getConfinementRect(const QRect rect) const;
--
--    miral::WindowManagerTools m_tools;
--    qtmir::WindowModelNotifier &m_windowModel;
--    qtmir::AppNotifier &m_appNotifier;
--    const QScopedPointer<QtEventFeeder> m_eventFeeder;
--    QVector<QRect> m_confinementRegions;
--    QMargins m_windowMargins[mir_window_types];
++    std::shared_ptr<qtmir::WindowManagementPolicy> m_wrapper;
  };
--#endif // WINDOWMANAGEMENTPOLICY_H
++#endif // WRAPPEDWINDOWMANAGEMENTPOLICY_H
 === modified file 'tests/mirserver/EventBuilder/CMakeLists.txt'
 --- tests/mirserver/EventBuilder/CMakeLists.txt	2016-10-28 10:32:49 +0000
 +++ tests/mirserver/EventBuilder/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -17,7 +17,7 @@
  target_link_libraries(
    EventBuilderTest
--  qpa-mirserver
++  qtmirserver
    ${GTEST_BOTH_LIBRARIES}
    ${GMOCK_LIBRARIES}
+ )
 === modified file 'tests/mirserver/QtEventFeeder/CMakeLists.txt'
 --- tests/mirserver/QtEventFeeder/CMakeLists.txt	2016-10-28 10:32:49 +0000
 +++ tests/mirserver/QtEventFeeder/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -19,7 +19,7 @@
  target_link_libraries(
    QtEventFeederTest
--  qpa-mirserver
++  qtmirserver
    ${GTEST_BOTH_LIBRARIES}
    ${GMOCK_LIBRARIES}
+ )
 === modified file 'tests/mirserver/Screen/CMakeLists.txt'
 --- tests/mirserver/Screen/CMakeLists.txt	2016-10-28 10:32:49 +0000
 +++ tests/mirserver/Screen/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -20,10 +20,12 @@
  target_link_libraries(
    ScreenTest
--  qpa-mirserver
++  qtmirserver
    ${GTEST_BOTH_LIBRARIES}
    ${GMOCK_LIBRARIES}
++
++  Qt5::Sensors
+ )
  add_test(Screen, ScreenTest)
 === modified file 'tests/mirserver/ScreensModel/CMakeLists.txt'
 --- tests/mirserver/ScreensModel/CMakeLists.txt	2016-11-23 20:45:02 +0000
 +++ tests/mirserver/ScreensModel/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -27,7 +27,7 @@
  target_link_libraries(
    ScreensModelTest
--  qpa-mirserver
++  qtmirserver
    -L${CMAKE_BINARY_DIR}/tests/framework
    qtmir-test-framework-static
 === modified file 'tests/mirserver/miral/CMakeLists.txt'
 --- tests/mirserver/miral/CMakeLists.txt	2016-12-09 12:33:31 +0000
 +++ tests/mirserver/miral/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -4,13 +4,13 @@
+ )
  include_directories(
--  ${CMAKE_SOURCE_DIR}/src/platforms/mirserver/miral
++    ${CMAKE_SOURCE_DIR}/include
+ )
  add_executable(MirALTests ${MIRAL_TEST_SOURCES})
  target_link_libraries(MirALTests
--  qpa-mirserver
++  qtmirserver
    ${GTEST_BOTH_LIBRARIES}
    ${GMOCK_LIBRARIES}
+ )
 === modified file 'tests/mirserver/miral/edid_test.cpp'
 --- tests/mirserver/miral/edid_test.cpp	2017-01-27 08:56:34 +0000
 +++ tests/mirserver/miral/edid_test.cpp	2017-04-05 10:39:22 +0000
@@ -18,7 +18,7 @@
  #include <gtest/gtest.h>
  #include <numeric>
--#include "edid.h"
++#include "qtmir/miral/edid.h"
  using namespace miral;
 === modified file 'tests/modules/Application/CMakeLists.txt'
 --- tests/modules/Application/CMakeLists.txt	2016-11-03 20:17:46 +0000
 +++ tests/modules/Application/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -14,7 +14,7 @@
    ${MIRAL_INCLUDE_DIRS}
    ${MIRSERVER_INCLUDE_DIRS}
    ${Qt5Core_INCLUDE_DIRS}
--  ${Qt5GUI_INCLUDE_DIRS}
++  ${Qt5Gui_INCLUDE_DIRS}
    ${Qt5Quick_INCLUDE_DIRS}
    ${Qt5DBus_INCLUDE_DIRS}
+ )
 === modified file 'tests/modules/WindowManager/CMakeLists.txt'
 --- tests/modules/WindowManager/CMakeLists.txt	2016-11-03 20:17:46 +0000
 +++ tests/modules/WindowManager/CMakeLists.txt	2017-04-05 10:39:22 +0000
@@ -7,6 +7,7 @@
+ )
  include_directories(
++  ${CMAKE_SOURCE_DIR}/include
    ${CMAKE_SOURCE_DIR}/src/common
    ${CMAKE_SOURCE_DIR}/src/modules
    ${CMAKE_SOURCE_DIR}/src/platforms/mirserver

QtMir

Merge lp:~unity-team/qtmir/qtmir.api into lp:qtmir

Commit message

Description of the change

Unmerged revisions

Preview Diff

Subscribers