Merge lp:~alan-griffiths/qtmir/import-WindowManagement-code-from-Mir-examples into lp:qtmir

[Alan Griffiths]

Copy the Window Management work-in-progress from Mir examples.

Copy the Window Management work-in-progress from Mir examples. (Just builds the library, no attempt to use it yet.)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:418
http://jenkins.qa.ubuntu.com/job/qtmir-ci/578/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/274
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/274
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/274/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/156
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/311/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/311/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/156/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Why Wily?

(Failures are unrelated to MP)

[Daniel d'Andrada (dandrader)]

In src/platforms/mirserver/wm-wip/server_example_window_management_info.h

"""
+ std::shared_ptr <scene::Surface> titlebar;
""

A QML shell won't be using mir surfaces for placing title bars. They will be QML items in the compositor's qml scene. Mir will be oblivious to that.

[Daniel d'Andrada (dandrader)]

"""
    void init_titlebar(std::shared_ptr <scene::Surface> const& surface);

    void paint_titlebar(int intensity);
"""

Likewise

[Daniel d'Andrada (dandrader)]

I don't get the point of dumping this code, unmodified, here in qtmir.

[Alan Griffiths (alan-griffiths)]

> I don't get the point of dumping this code, unmodified, here in qtmir.

This code is a snapshot of the different Mir examples of Window Management ("canonical", "tiling", "fullscreen"). While these are simplistic examples they are also helpful reference cases to getting generic WM support right.

The the code isn't published by libmirserver as mir-team do not want to publish the API until we get it stable, and we've been using the feedback from the Mir examples to evolve it. It is a work-in-progress and now want feedback from integration into Qtmir.

"Dumping" it here accomplishes two goals:

/1/ it makes it available to Qtmir without exposing it in the Mir API
/2/ feedback is easier to accomplish with the code here, so that we can change it without tying it to the Mir release cycle.

In the medium term changes will be fed back into Mir, published as a supported API and the code deleted from Qtmir.

To aid the tracking of changes for feedback to Mir this MI is just the unmodified code. Any tailoring for the needs of Qtmir or Unity8 will be done in subsequent MPs.

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:418
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/8/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

[lp:~alan-griffiths/qtmir/import-WindowManagement-code-from-Mir-examples]

419. By Alan Griffiths on 2016-01-16

merge lp:qtmir

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:419
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/16/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:419
http://jenkins.qa.ubuntu.com/job/qtmir-ci/640/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/334/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/336/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/216/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/371/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/373/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/216/console

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

review: Needs Fixing (continuous-integration)

[lp:~alan-griffiths/qtmir/import-WindowManagement-code-from-Mir-examples]

420. By Alan Griffiths on 2016-01-17

Re-sync with mir/examples

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:420
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/17/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:420
http://jenkins.qa.ubuntu.com/job/qtmir-ci/641/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/335
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/337
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/337/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/217
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/372/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/374/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/217/console

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

review: Needs Fixing (continuous-integration)

[Alan Griffiths (alan-griffiths)]

FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/372/console

The following packages have unmet dependencies:
 pbuilder-satisfydepends-dummy : Depends: libmirclient-dev (>= 0.18.0) but 0.17.0+15.10.20151008.2-0ubuntu1 is to be installed.
                                 Depends: libmircommon-dev (>= 0.18.0) but 0.17.0+15.10.20151008.2-0ubuntu1 is to be installed.
                                 Depends: libmirserver-dev (>= 0.18.0) but it is not going to be installed.
                                 Depends: libunity-api-dev (>= 7.104) but it is not going to be installed.

Do we care about wily (and Mir 0,17 support) here?

[Gerry Boland (gerboland)]

Can you please have this be only built when a cmake flag is set? Just to avoid building it unnecessarily.

review: Needs Fixing

[lp:~alan-griffiths/qtmir/import-WindowManagement-code-from-Mir-examples]

421. By Alan Griffiths on 2016-01-20

Only build the mir example Window Managers with cmake -DEXAMPLE_MIR_WINDOW_MANAGERS=on

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:421
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/23/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

[lp:~alan-griffiths/qtmir/import-WindowManagement-code-from-Mir-examples]

422. By Alan Griffiths on 2016-01-20

Fix compile options

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:421
http://jenkins.qa.ubuntu.com/job/qtmir-ci/647/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/341
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/343
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/343/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/223
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/378/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/380/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/223/console

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

review: Needs Fixing (continuous-integration)

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:422
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/24/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:422
http://jenkins.qa.ubuntu.com/job/qtmir-ci/650/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/344
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/346
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/346/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-i386-ci/226
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-amd64-ci/381/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-armhf-ci/383/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-wily-i386-ci/226/console

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

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

LGTM

review: Approve

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:422
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-1-ci/51/
Executed test runs:

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

review: Needs Fixing (continuous-integration)

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-12-07 10:51:03 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2016-01-20 19:52:54 +0000
@@ -36,6 +36,8 @@
     ${APPLICATION_API_INCLUDE_DIRS}
 )
 
+add_subdirectory(wm-wip)
+
 # We have to remove -pedantic for tracepoints.c
 string (REPLACE " -pedantic " " " CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
 # Needed to compile tracepoints in C99 mode.

=== added directory 'src/platforms/mirserver/wm-wip'
=== added file 'src/platforms/mirserver/wm-wip/CMakeLists.txt'
--- src/platforms/mirserver/wm-wip/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/CMakeLists.txt	2016-01-20 19:52:54 +0000
@@ -0,0 +1,22 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC")
+
+add_library(experimentalwindowmanager STATIC
+  server_example_basic_window_manager.cpp
+  server_example_basic_window_manager.h
+  server_example_window_management_info.cpp
+  server_example_window_management_info.h
+)
+
+
+if (EXAMPLE_MIR_WINDOW_MANAGERS)
+
+add_library(examplewindowmanager STATIC
+  server_example_canonical_window_manager.h
+  server_example_tiling_window_manager.h
+  server_example_window_management.h
+  server_example_canonical_window_manager.cpp
+  server_example_tiling_window_manager.cpp
+  server_example_window_management.cpp
+)
+
+endif()

=== added file 'src/platforms/mirserver/wm-wip/README'
--- src/platforms/mirserver/wm-wip/README	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/README	2016-01-20 19:52:54 +0000
@@ -0,0 +1,5 @@
+examples for mir clients. you should have package 'libmirclient-dev' installed
+
+you can compile with a command like:
+    g++ -std=c++0x -o mir_demo_client_scroll `pkg-config --libs --cflags mirclient` demo_client_scroll.cpp graphics_utils.cpp
+    gcc -o mir_demo_client_flicker `pkg-config --libs --cflags mirclient` demo_client_flicker.c

=== added file 'src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_basic_window_manager.cpp	2016-01-20 19:52:54 +0000
@@ -0,0 +1,312 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_basic_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+
+namespace me = mir::examples;
+
+me::BasicWindowManager::BasicWindowManager(
+    shell::FocusController* focus_controller,
+    std::unique_ptr<WindowManagementPolicy> policy) :
+    focus_controller(focus_controller),
+    policy(std::move(policy))
+{
+}
+
+void me::BasicWindowManager::add_session(std::shared_ptr<scene::Session> const& session)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    session_info[session] = SessionInfo();
+    policy->handle_session_info_updated(session_info, displays);
+}
+
+void me::BasicWindowManager::remove_session(std::shared_ptr<scene::Session> const& session)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    session_info.erase(session);
+    policy->handle_session_info_updated(session_info, displays);
+}
+
+auto me::BasicWindowManager::add_surface(
+    std::shared_ptr<scene::Session> const& session,
+    scene::SurfaceCreationParameters const& params,
+    std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+-> frontend::SurfaceId
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    scene::SurfaceCreationParameters const placed_params = policy->handle_place_new_surface(session, params);
+    auto const result = build(session, placed_params);
+    auto const surface = session->surface(result);
+    surface_info.emplace(surface, SurfaceInfo{session, surface, placed_params});
+    policy->handle_new_surface(session, surface);
+    policy->generate_decorations_for(session, surface, surface_info, build);
+    return result;
+}
+
+void me::BasicWindowManager::modify_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    policy->handle_modify_surface(session, surface, modifications);
+}
+
+void me::BasicWindowManager::remove_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::weak_ptr<scene::Surface> const& surface)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    policy->handle_delete_surface(session, surface);
+
+    surface_info.erase(surface);
+}
+
+void me::BasicWindowManager::forget(std::weak_ptr<scene::Surface> const& surface)
+{
+    surface_info.erase(surface);
+}
+
+void me::BasicWindowManager::add_display(geometry::Rectangle const& area)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    displays.add(area);
+    policy->handle_displays_updated(session_info, displays);
+}
+
+void me::BasicWindowManager::remove_display(geometry::Rectangle const& area)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    displays.remove(area);
+    policy->handle_displays_updated(session_info, displays);
+}
+
+bool me::BasicWindowManager::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+    return policy->handle_keyboard_event(event);
+}
+
+bool me::BasicWindowManager::handle_touch_event(MirTouchEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+    return policy->handle_touch_event(event);
+}
+
+bool me::BasicWindowManager::handle_pointer_event(MirPointerEvent const* event)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    update_event_timestamp(event);
+
+    cursor = {
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    return policy->handle_pointer_event(event);
+}
+
+void me::BasicWindowManager::handle_raise_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    uint64_t timestamp)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    if (timestamp >= last_input_event_timestamp)
+        policy->handle_raise_surface(session, surface);
+}
+
+int me::BasicWindowManager::set_surface_attribute(
+    std::shared_ptr<scene::Session> const& /*session*/,
+    std::shared_ptr<scene::Surface> const& surface,
+    MirSurfaceAttrib attrib,
+    int value)
+{
+    std::lock_guard<decltype(mutex)> lock(mutex);
+    switch (attrib)
+    {
+    case mir_surface_attrib_state:
+    {
+        auto const state = policy->handle_set_state(surface, MirSurfaceState(value));
+        return surface->configure(attrib, state);
+    }
+    default:
+        return surface->configure(attrib, value);
+    }
+}
+
+auto me::BasicWindowManager::find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+-> std::shared_ptr<scene::Session>
+    {
+        for(auto& info : session_info)
+        {
+            if (predicate(info.second))
+            {
+                return info.first.lock();
+            }
+        }
+
+        return std::shared_ptr<scene::Session>{};
+    }
+
+auto me::BasicWindowManager::info_for(std::weak_ptr<scene::Session> const& session) const
+-> SessionInfo&
+{
+    return const_cast<SessionInfo&>(session_info.at(session));
+}
+
+auto me::BasicWindowManager::info_for(std::weak_ptr<scene::Surface> const& surface) const
+-> SurfaceInfo&
+{
+    return const_cast<SurfaceInfo&>(surface_info.at(surface));
+}
+
+auto me::BasicWindowManager::focused_session() const
+-> std::shared_ptr<scene::Session>
+{
+    return focus_controller->focused_session();
+}
+
+auto me::BasicWindowManager::focused_surface() const
+->std::shared_ptr<scene::Surface>
+{
+    return focus_controller->focused_surface();
+}
+
+void me::BasicWindowManager::focus_next_session()
+{
+    focus_controller->focus_next_session();
+}
+
+void me::BasicWindowManager::set_focus_to(
+    std::shared_ptr<scene::Session> const& focus,
+    std::shared_ptr<scene::Surface> const& surface)
+{
+    focus_controller->set_focus_to(focus, surface);
+}
+
+auto me::BasicWindowManager::surface_at(geometry::Point cursor) const
+-> std::shared_ptr<scene::Surface>
+{
+    return focus_controller->surface_at(cursor);
+}
+
+auto me::BasicWindowManager::active_display()
+-> geometry::Rectangle const
+{
+    geometry::Rectangle result;
+
+    // 1. If a window has input focus, whichever display contains the largest
+    //    proportion of the area of that window.
+    if (auto const surface = focused_surface())
+    {
+        auto const surface_rect = surface->input_bounds();
+        int max_overlap_area = -1;
+
+        for (auto const& display : displays)
+        {
+            auto const intersection = surface_rect.intersection_with(display).size;
+            if (intersection.width.as_int()*intersection.height.as_int() > max_overlap_area)
+            {
+                max_overlap_area = intersection.width.as_int()*intersection.height.as_int();
+                result = display;
+            }
+        }
+        return result;
+    }
+
+    // 2. Otherwise, if any window previously had input focus, for the window that had
+    //    it most recently, the display that contained the largest proportion of the
+    //    area of that window at the moment it closed, as long as that display is still
+    //    available.
+
+    // 3. Otherwise, the display that contains the pointer, if there is one.
+    for (auto const& display : displays)
+    {
+        if (display.contains(cursor))
+        {
+            // Ignore the (unspecified) possiblity of overlapping displays
+            return display;
+        }
+    }
+
+    // 4. Otherwise, the primary display, if there is one (for example, the laptop display).
+
+    // 5. Otherwise, the first display.
+    if (displays.size())
+        result = *displays.begin();
+
+    return result;
+}
+
+void me::BasicWindowManager::raise_tree(std::shared_ptr<scene::Surface> const& root)
+{
+    SurfaceSet surfaces;
+    std::function<void(std::weak_ptr<scene::Surface> const& surface)> const add_children =
+        [&,this](std::weak_ptr<scene::Surface> const& surface)
+            {
+            auto const& info = info_for(surface);
+            surfaces.insert(begin(info.children), end(info.children));
+            for (auto const& child : info.children)
+                add_children(child);
+            };
+
+    surfaces.insert(root);
+    add_children(root);
+
+    focus_controller->raise(surfaces);
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirKeyboardEvent const* kev)
+{
+    auto iev = mir_keyboard_event_input_event(kev);
+    last_input_event_timestamp = mir_input_event_get_event_time(iev);
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirPointerEvent const* pev)
+{
+    auto iev = mir_pointer_event_input_event(pev);
+    auto pointer_action = mir_pointer_event_action(pev);
+
+    if (pointer_action == mir_pointer_action_button_up ||
+        pointer_action == mir_pointer_action_button_down)
+    {
+        last_input_event_timestamp = mir_input_event_get_event_time(iev);
+    }
+}
+
+void me::BasicWindowManager::update_event_timestamp(MirTouchEvent const* tev)
+{
+    auto iev = mir_touch_event_input_event(tev);
+    auto touch_count = mir_touch_event_point_count(tev);
+    for (unsigned i = 0; i < touch_count; i++)
+    {
+        auto touch_action = mir_touch_event_action(tev, i);
+        if (touch_action == mir_touch_action_up ||
+            touch_action == mir_touch_action_down)
+        {
+            last_input_event_timestamp = mir_input_event_get_event_time(iev);
+            break;
+        }
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_basic_window_manager.h	2016-01-20 19:52:54 +0000
@@ -0,0 +1,252 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
+
+#include "server_example_window_management_info.h"
+
+#include "mir/geometry/rectangles.h"
+#include "mir/shell/abstract_shell.h"
+#include "mir/shell/window_manager.h"
+
+#include <map>
+#include <mutex>
+
+///\example server_example_basic_window_manager.h
+/// A generic policy-based window manager implementation
+
+namespace mir
+{
+namespace examples
+{
+using shell::SurfaceSet;
+
+/// The interface through which the policy instructs the controller.
+/// These functions assume that the BasicWindowManager data structures can be accessed freely.
+/// I.e. should only be invoked by the policy handle_... methods (where any necessary locks are held).
+class WindowManagerTools
+{
+public:
+    using SurfaceInfoMap = std::map<std::weak_ptr<scene::Surface>, SurfaceInfo, std::owner_less<std::weak_ptr<scene::Surface>>>;
+    using SessionInfoMap = std::map<std::weak_ptr<scene::Session>, SessionInfo, std::owner_less<std::weak_ptr<scene::Session>>>;
+
+    virtual auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+    -> std::shared_ptr<scene::Session> = 0;
+
+    virtual auto info_for(std::weak_ptr<scene::Session> const& session) const -> SessionInfo& = 0;
+
+    virtual auto info_for(std::weak_ptr<scene::Surface> const& surface) const -> SurfaceInfo& = 0;
+
+    virtual std::shared_ptr<scene::Session> focused_session() const = 0;
+
+    virtual std::shared_ptr<scene::Surface> focused_surface() const = 0;
+
+    virtual void focus_next_session() = 0;
+
+    virtual void set_focus_to(
+        std::shared_ptr<scene::Session> const& focus,
+        std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual auto surface_at(geometry::Point cursor) const -> std::shared_ptr<scene::Surface> = 0;
+
+    virtual auto active_display() -> geometry::Rectangle const = 0;
+
+    virtual void forget(std::weak_ptr<scene::Surface> const& surface) = 0;
+
+    virtual void raise_tree(std::shared_ptr<scene::Surface> const& root) = 0;
+
+    virtual ~WindowManagerTools() = default;
+    WindowManagerTools() = default;
+    WindowManagerTools(WindowManagerTools const&) = delete;
+    WindowManagerTools& operator=(WindowManagerTools const&) = delete;
+};
+
+class WindowManagementPolicy
+{
+public:
+    using SessionInfoMap = typename WindowManagerTools::SessionInfoMap;
+    using SurfaceInfoMap = typename WindowManagerTools::SurfaceInfoMap;
+
+    virtual void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays) = 0;
+
+    virtual void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays) = 0;
+
+    virtual auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+        -> scene::SurfaceCreationParameters = 0;
+
+    virtual void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications) = 0;
+
+    virtual void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface) = 0;
+
+    virtual int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value) = 0;
+
+    virtual void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_info,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const&, scene::SurfaceCreationParameters const&)> const& build) = 0;
+
+    virtual bool handle_keyboard_event(MirKeyboardEvent const* event) = 0;
+
+    virtual bool handle_touch_event(MirTouchEvent const* event) = 0;
+
+    virtual bool handle_pointer_event(MirPointerEvent const* event) = 0;
+
+    virtual void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface) = 0;
+
+    virtual ~WindowManagementPolicy() = default;
+    WindowManagementPolicy() = default;
+    WindowManagementPolicy(WindowManagementPolicy const&) = delete;
+    WindowManagementPolicy& operator=(WindowManagementPolicy const&) = delete;
+};
+
+/// A policy based window manager.
+/// This takes care of the management of any meta implementation held for the sessions and surfaces.
+class BasicWindowManager : public virtual shell::WindowManager,
+    protected WindowManagerTools
+{
+protected:
+    BasicWindowManager(
+        shell::FocusController* focus_controller,
+        std::unique_ptr<WindowManagementPolicy> policy);
+
+public:
+    using typename WindowManagerTools::SurfaceInfoMap;
+    using typename WindowManagerTools::SessionInfoMap;
+
+    void add_session(std::shared_ptr<scene::Session> const& session) override;
+
+    void remove_session(std::shared_ptr<scene::Session> const& session) override;
+
+    auto add_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& params,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+    -> frontend::SurfaceId override;
+
+    void modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications) override;
+
+    void remove_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::weak_ptr<scene::Surface> const& surface) override;
+
+    void forget(std::weak_ptr<scene::Surface> const& surface) override;
+
+    void add_display(geometry::Rectangle const& area) override;
+
+    void remove_display(geometry::Rectangle const& area) override;
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event) override;
+
+    bool handle_touch_event(MirTouchEvent const* event) override;
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        uint64_t timestamp) override;
+
+    int set_surface_attribute(
+        std::shared_ptr<scene::Session> const& /*session*/,
+        std::shared_ptr<scene::Surface> const& surface,
+        MirSurfaceAttrib attrib,
+        int value) override;
+
+    auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
+    -> std::shared_ptr<scene::Session> override;
+
+    auto info_for(std::weak_ptr<scene::Session> const& session) const -> SessionInfo& override;
+
+    auto info_for(std::weak_ptr<scene::Surface> const& surface) const -> SurfaceInfo& override;
+
+    std::shared_ptr<scene::Session> focused_session() const override;
+
+    std::shared_ptr<scene::Surface> focused_surface() const override;
+
+    void focus_next_session() override;
+
+    void set_focus_to(
+        std::shared_ptr<scene::Session> const& focus,
+        std::shared_ptr<scene::Surface> const& surface) override;
+
+    auto surface_at(geometry::Point cursor) const -> std::shared_ptr<scene::Surface> override;
+
+    auto active_display() -> geometry::Rectangle const override;
+
+    void raise_tree(std::shared_ptr<scene::Surface> const& root) override;
+
+private:
+    shell::FocusController* const focus_controller;
+    std::unique_ptr<WindowManagementPolicy> const policy;
+
+    std::mutex mutex;
+    SessionInfoMap session_info;
+    SurfaceInfoMap surface_info;
+    geometry::Rectangles displays;
+    geometry::Point cursor;
+    uint64_t last_input_event_timestamp{0};
+
+    void update_event_timestamp(MirKeyboardEvent const* kev);
+    void update_event_timestamp(MirPointerEvent const* pev);
+    void update_event_timestamp(MirTouchEvent const* tev);
+};
+
+/// A policy based window manager. This exists to initialize BasicWindowManager and
+/// the WMPolicy (in an awkward manner).
+/// TODO revisit this initialization sequence.
+template<typename WMPolicy>
+class WindowManagerBuilder : public BasicWindowManager
+{
+public:
+
+    template <typename... PolicyArgs>
+    WindowManagerBuilder(
+        shell::FocusController* focus_controller,
+        PolicyArgs&&... policy_args) :
+        BasicWindowManager(
+            focus_controller,
+            build_policy(std::forward<PolicyArgs>(policy_args)...))
+    {
+    }
+
+private:
+    template <typename... PolicyArgs>
+    auto build_policy(PolicyArgs&&... policy_args)
+    -> std::unique_ptr<WMPolicy>
+    {
+        return std::unique_ptr<WMPolicy>(
+            new WMPolicy(this, std::forward<PolicyArgs>(policy_args)...));
+    }
+};
+}
+}
+
+#endif /* MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.cpp	2016-01-20 19:52:54 +0000
@@ -0,0 +1,946 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_canonical_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/surface_ready_observer.h"
+#include "mir/shell/display_layout.h"
+
+#include <linux/input.h>
+#include <csignal>
+#include <algorithm>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+using namespace mir::geometry;
+
+///\example server_example_canonical_window_manager.cpp
+// Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
+
+namespace
+{
+int const title_bar_height = 10;
+Size titlebar_size_for_window(Size window_size)
+{
+    return {window_size.width, Height{title_bar_height}};
+}
+
+Point titlebar_position_for_window(Point window_position)
+{
+    return {
+        window_position.x,
+        window_position.y - DeltaY(title_bar_height)
+    };
+}
+}
+
+me::CanonicalWindowManagerPolicyCopy::CanonicalWindowManagerPolicyCopy(
+    WindowManagerTools* const tools,
+    std::shared_ptr<shell::DisplayLayout> const& display_layout) :
+    tools{tools},
+    display_layout{display_layout}
+{
+}
+
+void me::CanonicalWindowManagerPolicyCopy::click(Point cursor)
+{
+    if (auto const surface = tools->surface_at(cursor))
+        select_active_surface(surface);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_session_info_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/)
+{
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_displays_updated(SessionInfoMap& /*session_info*/, Rectangles const& displays)
+{
+    display_area = displays.bounding_rectangle();
+
+    for (auto const weak_surface : fullscreen_surfaces)
+    {
+        if (auto const surface = weak_surface.lock())
+        {
+            auto const& info = tools->info_for(weak_surface);
+            Rectangle rect{surface->top_left(), surface->size()};
+
+            display_layout->place_in_output(info.output_id.value(), rect);
+            surface->move_to(rect.top_left);
+            surface->resize(rect.size);
+        }
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::resize(Point cursor)
+{
+    select_active_surface(tools->surface_at(old_cursor));
+    resize(active_surface(), cursor, old_cursor, display_area);
+}
+
+auto me::CanonicalWindowManagerPolicyCopy::handle_place_new_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& request_parameters)
+-> ms::SurfaceCreationParameters
+{
+    auto parameters = request_parameters;
+    auto surf_type = parameters.type.is_set() ? parameters.type.value() : mir_surface_type_normal;
+    bool const needs_titlebar = SurfaceInfo::needs_titlebar(surf_type);
+
+    if (needs_titlebar)
+        parameters.size.height = parameters.size.height + DeltaY{title_bar_height};
+
+    if (!parameters.state.is_set())
+        parameters.state = mir_surface_state_restored;
+
+    auto const active_display = tools->active_display();
+
+    auto const width = parameters.size.width.as_int();
+    auto const height = parameters.size.height.as_int();
+
+    bool positioned = false;
+
+    auto const parent = parameters.parent.lock();
+
+    if (parameters.output_id != mir::graphics::DisplayConfigurationOutputId{0})
+    {
+        Rectangle rect{parameters.top_left, parameters.size};
+        display_layout->place_in_output(parameters.output_id, rect);
+        parameters.top_left = rect.top_left;
+        parameters.size = rect.size;
+        parameters.state = mir_surface_state_fullscreen;
+        positioned = true;
+    }
+    else if (!parent) // No parent => client can't suggest positioning
+    {
+        if (auto const default_surface = session->default_surface())
+        {
+            static Displacement const offset{title_bar_height, title_bar_height};
+
+            parameters.top_left = default_surface->top_left() + offset;
+
+            geometry::Rectangle display_for_app{default_surface->top_left(), default_surface->size()};
+
+            display_layout->size_to_output(display_for_app);
+
+            positioned = display_for_app.overlaps(Rectangle{parameters.top_left, parameters.size});
+        }
+    }
+
+    if (parent && parameters.aux_rect.is_set() && parameters.edge_attachment.is_set())
+    {
+        auto const edge_attachment = parameters.edge_attachment.value();
+        auto const aux_rect = parameters.aux_rect.value();
+        auto const parent_top_left = parent->top_left();
+        auto const top_left = aux_rect.top_left     -Point{} + parent_top_left;
+        auto const top_right= aux_rect.top_right()  -Point{} + parent_top_left;
+        auto const bot_left = aux_rect.bottom_left()-Point{} + parent_top_left;
+
+        if (edge_attachment & mir_edge_attachment_vertical)
+        {
+            if (active_display.contains(top_right + Displacement{width, height}))
+            {
+                parameters.top_left = top_right;
+                positioned = true;
+            }
+            else if (active_display.contains(top_left + Displacement{-width, height}))
+            {
+                parameters.top_left = top_left + Displacement{-width, 0};
+                positioned = true;
+            }
+        }
+
+        if (edge_attachment & mir_edge_attachment_horizontal)
+        {
+            if (active_display.contains(bot_left + Displacement{width, height}))
+            {
+                parameters.top_left = bot_left;
+                positioned = true;
+            }
+            else if (active_display.contains(top_left + Displacement{width, -height}))
+            {
+                parameters.top_left = top_left + Displacement{0, -height};
+                positioned = true;
+            }
+        }
+    }
+    else if (parent)
+    {
+        //  o Otherwise, if the dialog is not the same as any previous dialog for the
+        //    same parent window, and/or it does not have user-customized position:
+        //      o It should be optically centered relative to its parent, unless this
+        //        would overlap or cover the title bar of the parent.
+        //      o Otherwise, it should be cascaded vertically (but not horizontally)
+        //        relative to its parent, unless, this would cause at least part of
+        //        it to extend into shell space.
+        auto const parent_top_left = parent->top_left();
+        auto const centred = parent_top_left
+             + 0.5*(as_displacement(parent->size()) - as_displacement(parameters.size))
+             - DeltaY{(parent->size().height.as_int()-height)/6};
+
+        parameters.top_left = centred;
+        positioned = true;
+    }
+
+    if (!positioned)
+    {
+        auto const centred = active_display.top_left
+            + 0.5*(as_displacement(active_display.size) - as_displacement(parameters.size))
+            - DeltaY{(active_display.size.height.as_int()-height)/6};
+
+        switch (parameters.state.value())
+        {
+        case mir_surface_state_fullscreen:
+        case mir_surface_state_maximized:
+            parameters.top_left = active_display.top_left;
+            parameters.size = active_display.size;
+            break;
+
+        case mir_surface_state_vertmaximized:
+            parameters.top_left = centred;
+            parameters.top_left.y = active_display.top_left.y;
+            parameters.size.height = active_display.size.height;
+            break;
+
+        case mir_surface_state_horizmaximized:
+            parameters.top_left = centred;
+            parameters.top_left.x = active_display.top_left.x;
+            parameters.size.width = active_display.size.width;
+            break;
+
+        default:
+            parameters.top_left = centred;
+        }
+
+        if (parameters.top_left.y < display_area.top_left.y)
+            parameters.top_left.y = display_area.top_left.y;
+    }
+
+    if (parameters.state != mir_surface_state_fullscreen && needs_titlebar)
+    {
+        parameters.top_left.y = parameters.top_left.y + DeltaY{title_bar_height};
+        parameters.size.height = parameters.size.height - DeltaY{title_bar_height};
+    }
+
+    return parameters;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::generate_decorations_for(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    SurfaceInfoMap& surface_map,
+    std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build)
+{
+    if (!SurfaceInfo::needs_titlebar(surface->type()))
+        return;
+
+    auto format = mir_pixel_format_xrgb_8888;
+    ms::SurfaceCreationParameters params;
+    params.of_size(titlebar_size_for_window(surface->size()))
+        .of_name("decoration")
+        .of_pixel_format(format)
+        .of_buffer_usage(mir::graphics::BufferUsage::software)
+        .of_position(titlebar_position_for_window(surface->top_left()))
+        .of_type(mir_surface_type_gloss);
+    auto id = build(session, params);
+    auto titlebar = session->surface(id);
+    titlebar->set_alpha(0.9);
+
+    auto& surface_info = tools->info_for(surface);
+    surface_info.titlebar = titlebar;
+    surface_info.titlebar_id = id;
+    surface_info.children.push_back(titlebar);
+
+    SurfaceInfo& titlebar_info =
+            surface_map.emplace(titlebar, SurfaceInfo{session, titlebar, {}}).first->second;
+    titlebar_info.is_titlebar = true;
+    titlebar_info.parent = surface;
+    titlebar_info.init_titlebar(titlebar);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_new_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& surface)
+{
+    auto& surface_info = tools->info_for(surface);
+    if (auto const parent = surface_info.parent.lock())
+    {
+        tools->info_for(parent).children.push_back(surface);
+    }
+
+    tools->info_for(session).surfaces.push_back(surface);
+
+    if (surface_info.can_be_active())
+    {
+        surface->add_observer(std::make_shared<shell::SurfaceReadyObserver>(
+            [this](std::shared_ptr<scene::Session> const& /*session*/,
+                   std::shared_ptr<scene::Surface> const& surface)
+                {
+                    select_active_surface(surface);
+                },
+            session,
+            surface));
+    }
+
+    if (surface_info.state == mir_surface_state_fullscreen)
+        fullscreen_surfaces.insert(surface);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_modify_surface(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    auto& surface_info_old = tools->info_for(surface);
+
+    auto surface_info = surface_info_old;
+
+    if (modifications.parent.is_set())
+        surface_info.parent = modifications.parent.value();
+
+    if (modifications.type.is_set() &&
+        surface_info.type != modifications.type.value())
+    {
+        auto const new_type = modifications.type.value();
+
+        if (!surface_info.can_morph_to(new_type))
+        {
+            throw std::runtime_error("Unsupported surface type change");
+        }
+
+        surface_info.type = new_type;
+
+        if (surface_info.must_not_have_parent())
+        {
+            if (modifications.parent.is_set())
+                throw std::runtime_error("Target surface type does not support parent");
+
+            surface_info.parent.reset();
+        }
+        else if (surface_info.must_have_parent())
+        {
+            if (!surface_info.parent.lock())
+                throw std::runtime_error("Target surface type requires parent");
+        }
+
+        surface->configure(mir_surface_attrib_type, new_type);
+    }
+
+    #define COPY_IF_SET(field)\
+        if (modifications.field.is_set())\
+            surface_info.field = modifications.field.value()
+
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(min_height);
+    COPY_IF_SET(max_width);
+    COPY_IF_SET(max_height);
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(width_inc);
+    COPY_IF_SET(height_inc);
+    COPY_IF_SET(min_aspect);
+    COPY_IF_SET(max_aspect);
+    COPY_IF_SET(output_id);
+
+    #undef COPY_IF_SET
+
+    std::swap(surface_info, surface_info_old);
+
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+
+    if (modifications.streams.is_set())
+    {
+        auto v = modifications.streams.value();
+        std::vector<shell::StreamSpecification> l (v.begin(), v.end());
+        session->configure_streams(*surface, l);
+    }
+
+    if (modifications.input_shape.is_set())
+    {
+        surface->set_input_region(modifications.input_shape.value());
+    }
+
+    if (modifications.width.is_set() || modifications.height.is_set())
+    {
+        auto new_size = surface->size();
+
+        if (modifications.width.is_set())
+            new_size.width = modifications.width.value();
+
+        if (modifications.height.is_set())
+            new_size.height = modifications.height.value();
+
+        auto top_left = surface->top_left();
+
+        surface_info.constrain_resize(
+            surface,
+            top_left,
+            new_size,
+            false,
+            false,
+            display_area);
+
+        apply_resize(surface, surface_info.titlebar, top_left, new_size);
+    }
+
+    if (modifications.state.is_set())
+    {
+        auto const state = handle_set_state(surface, modifications.state.value());
+        surface->configure(mir_surface_attrib_state, state);
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+{
+    fullscreen_surfaces.erase(surface);
+
+    auto& info = tools->info_for(surface);
+
+    if (auto const parent = info.parent.lock())
+    {
+        auto& siblings = tools->info_for(parent).children;
+
+        for (auto i = begin(siblings); i != end(siblings); ++i)
+        {
+            if (surface.lock() == i->lock())
+            {
+                siblings.erase(i);
+                break;
+            }
+        }
+    }
+
+    session->destroy_surface(surface);
+    if (info.titlebar)
+    {
+        session->destroy_surface(info.titlebar_id);
+        tools->forget(info.titlebar);
+    }
+
+    auto& surfaces = tools->info_for(session).surfaces;
+
+    for (auto i = begin(surfaces); i != end(surfaces); ++i)
+    {
+        if (surface.lock() == i->lock())
+        {
+            surfaces.erase(i);
+            break;
+        }
+    }
+
+    if (surfaces.empty() && session == tools->focused_session())
+    {
+        active_surface_.reset();
+        tools->focus_next_session();
+        select_active_surface(tools->focused_surface());
+    }
+}
+
+int me::CanonicalWindowManagerPolicyCopy::handle_set_state(std::shared_ptr<ms::Surface> const& surface, MirSurfaceState value)
+{
+    auto& info = tools->info_for(surface);
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+    case mir_surface_state_maximized:
+    case mir_surface_state_vertmaximized:
+    case mir_surface_state_horizmaximized:
+    case mir_surface_state_fullscreen:
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        break;
+
+    default:
+        return info.state;
+    }
+
+    if (info.state == mir_surface_state_restored)
+    {
+        info.restore_rect = {surface->top_left(), surface->size()};
+    }
+
+    if (info.state != mir_surface_state_fullscreen)
+    {
+        info.output_id = decltype(info.output_id){};
+        fullscreen_surfaces.erase(surface);
+    }
+    else
+    {
+        fullscreen_surfaces.insert(surface);
+    }
+
+    if (info.state == value)
+    {
+        return info.state;
+    }
+
+    auto const old_pos = surface->top_left();
+    Displacement movement;
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+        movement = info.restore_rect.top_left - old_pos;
+        surface->resize(info.restore_rect.size);
+        if (info.titlebar)
+        {
+            info.titlebar->resize(titlebar_size_for_window(info.restore_rect.size));
+            info.titlebar->show();
+        }
+        break;
+
+    case mir_surface_state_maximized:
+        movement = display_area.top_left - old_pos;
+        surface->resize(display_area.size);
+        if (info.titlebar)
+            info.titlebar->hide();
+        break;
+
+    case mir_surface_state_horizmaximized:
+        movement = Point{display_area.top_left.x, info.restore_rect.top_left.y} - old_pos;
+        surface->resize({display_area.size.width, info.restore_rect.size.height});
+        if (info.titlebar)
+        {
+            info.titlebar->resize(titlebar_size_for_window({display_area.size.width, info.restore_rect.size.height}));
+            info.titlebar->show();
+        }
+        break;
+
+    case mir_surface_state_vertmaximized:
+        movement = Point{info.restore_rect.top_left.x, display_area.top_left.y} - old_pos;
+        surface->resize({info.restore_rect.size.width, display_area.size.height});
+        if (info.titlebar)
+            info.titlebar->hide();
+        break;
+
+    case mir_surface_state_fullscreen:
+    {
+        Rectangle rect{old_pos, surface->size()};
+
+        if (info.output_id.is_set())
+        {
+            display_layout->place_in_output(info.output_id.value(), rect);
+        }
+        else
+        {
+            display_layout->size_to_output(rect);
+        }
+
+        movement = rect.top_left - old_pos;
+        surface->resize(rect.size);
+        break;
+    }
+
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        if (info.titlebar)
+            info.titlebar->hide();
+        surface->hide();
+        return info.state = value;
+
+    default:
+        break;
+    }
+
+    // TODO It is rather simplistic to move a tree WRT the top_left of the root
+    // TODO when resizing. But for more sophistication we would need to encode
+    // TODO some sensible layout rules.
+    move_tree(surface, movement);
+
+    info.state = value;
+
+    if (info.is_visible())
+        surface->show();
+
+    return info.state;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::drag(Point cursor)
+{
+    select_active_surface(tools->surface_at(old_cursor));
+    drag(active_surface(), cursor, old_cursor, display_area);
+}
+
+void me::CanonicalWindowManagerPolicyCopy::handle_raise_surface(
+    std::shared_ptr<ms::Session> const& /*session*/,
+    std::shared_ptr<ms::Surface> const& surface)
+{
+    select_active_surface(surface);
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    auto const action = mir_keyboard_event_action(event);
+    auto const scan_code = mir_keyboard_event_scan_code(event);
+    auto const modifiers = mir_keyboard_event_modifiers(event) & modifier_mask;
+
+    if (action == mir_keyboard_action_down && scan_code == KEY_F11)
+    {
+        switch (modifiers)
+        {
+        case mir_input_event_modifier_alt:
+            toggle(mir_surface_state_maximized);
+            return true;
+
+        case mir_input_event_modifier_shift:
+            toggle(mir_surface_state_vertmaximized);
+            return true;
+
+        case mir_input_event_modifier_ctrl:
+            toggle(mir_surface_state_horizmaximized);
+            return true;
+
+        default:
+            break;
+        }
+    }
+    else if (action == mir_keyboard_action_down && scan_code == KEY_F4)
+    {
+        if (auto const session = tools->focused_session())
+        {
+            switch (modifiers)
+            {
+            case mir_input_event_modifier_alt:
+                kill(session->process_id(), SIGTERM);
+                return true;
+
+            case mir_input_event_modifier_ctrl:
+                if (auto const surf = session->default_surface())
+                {
+                    surf->request_client_surface_close();
+                    return true;
+                }
+
+            default:
+                break;
+            }
+        }
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_TAB)
+    {
+        tools->focus_next_session();
+        if (auto const surface = tools->focused_surface())
+            select_active_surface(surface);
+
+        return true;
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_GRAVE)
+    {
+        if (auto const prev = tools->focused_surface())
+        {
+            if (auto const app = tools->focused_session())
+                select_active_surface(app->surface_after(prev));
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_touch_event(MirTouchEvent const* event)
+{
+    auto const count = mir_touch_event_point_count(event);
+
+    long total_x = 0;
+    long total_y = 0;
+
+    for (auto i = 0U; i != count; ++i)
+    {
+        total_x += mir_touch_event_axis_value(event, i, mir_touch_axis_x);
+        total_y += mir_touch_event_axis_value(event, i, mir_touch_axis_y);
+    }
+
+    Point const cursor{total_x/count, total_y/count};
+
+    bool is_drag = true;
+    for (auto i = 0U; i != count; ++i)
+    {
+        switch (mir_touch_event_action(event, i))
+        {
+        case mir_touch_action_up:
+            return false;
+
+        case mir_touch_action_down:
+            is_drag = false;
+
+        case mir_touch_action_change:
+            continue;
+        }
+    }
+
+    bool consumes_event = false;
+    if (is_drag)
+    {
+        switch (count)
+        {
+        case 2:
+            resize(cursor);
+            consumes_event = true;
+            break;
+
+        case 3:
+            drag(cursor);
+            consumes_event = true;
+            break;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::handle_pointer_event(MirPointerEvent const* event)
+{
+    auto const action = mir_pointer_event_action(event);
+    auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
+    Point const cursor{
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    bool consumes_event = false;
+
+    if (action == mir_pointer_action_button_down)
+    {
+        click(cursor);
+    }
+    else if (action == mir_pointer_action_motion &&
+             modifiers == mir_input_event_modifier_alt)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            drag(cursor);
+            consumes_event = true;
+        }
+
+        if (mir_pointer_event_button_state(event, mir_pointer_button_tertiary))
+        {
+            resize(cursor);
+            consumes_event = true;
+        }
+    }
+    else if (action == mir_pointer_action_motion && !modifiers)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            if (auto const possible_titlebar = tools->surface_at(old_cursor))
+            {
+                if (tools->info_for(possible_titlebar).is_titlebar)
+                {
+                    drag(cursor);
+                    consumes_event = true;
+                }
+            }
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::toggle(MirSurfaceState state)
+{
+    if (auto const surface = active_surface())
+    {
+        auto& info = tools->info_for(surface);
+
+        if (info.state == state)
+            state = mir_surface_state_restored;
+
+        auto const value = handle_set_state(surface, MirSurfaceState(state));
+        surface->configure(mir_surface_attrib_state, value);
+    }
+}
+
+void me::CanonicalWindowManagerPolicyCopy::select_active_surface(std::shared_ptr<ms::Surface> const& surface)
+{
+    if (surface == active_surface_.lock())
+        return;
+
+    if (!surface)
+    {
+        if (auto const active_surface = active_surface_.lock())
+        {
+            if (auto const titlebar = tools->info_for(active_surface).titlebar)
+            {
+                tools->info_for(titlebar).paint_titlebar(0x3F);
+            }
+        }
+
+        if (active_surface_.lock())
+            tools->set_focus_to({}, {});
+
+        active_surface_.reset();
+        return;
+    }
+
+    auto const& info_for = tools->info_for(surface);
+
+    if (info_for.can_be_active())
+    {
+        if (auto const active_surface = active_surface_.lock())
+        {
+            if (auto const titlebar = tools->info_for(active_surface).titlebar)
+            {
+                tools->info_for(titlebar).paint_titlebar(0x3F);
+            }
+        }
+        if (auto const titlebar = tools->info_for(surface).titlebar)
+        {
+            tools->info_for(titlebar).paint_titlebar(0xFF);
+        }
+        tools->set_focus_to(info_for.session.lock(), surface);
+        tools->raise_tree(surface);
+        active_surface_ = surface;
+    }
+    else
+    {
+        // Cannot have input focus - try the parent
+        if (auto const parent = info_for.parent.lock())
+            select_active_surface(parent);
+    }
+}
+
+auto me::CanonicalWindowManagerPolicyCopy::active_surface() const
+-> std::shared_ptr<ms::Surface>
+{
+    if (auto const surface = active_surface_.lock())
+        return surface;
+
+    if (auto const session = tools->focused_session())
+    {
+        if (auto const surface = session->default_surface())
+            return surface;
+    }
+
+    return std::shared_ptr<ms::Surface>{};
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::resize(std::shared_ptr<ms::Surface> const& surface, Point cursor, Point old_cursor, Rectangle bounds)
+{
+    if (!surface || !surface->input_area_contains(old_cursor))
+        return false;
+
+    auto const top_left = surface->top_left();
+    Rectangle const old_pos{top_left, surface->size()};
+
+    auto anchor = top_left;
+
+    for (auto const& corner : {
+        old_pos.top_right(),
+        old_pos.bottom_left(),
+        old_pos.bottom_right()})
+    {
+        if ((old_cursor - anchor).length_squared() <
+            (old_cursor - corner).length_squared())
+        {
+            anchor = corner;
+        }
+    }
+
+    bool const left_resize = anchor.x != top_left.x;
+    bool const top_resize  = anchor.y != top_left.y;
+    int const x_sign = left_resize? -1 : 1;
+    int const y_sign = top_resize?  -1 : 1;
+
+    auto const delta = cursor-old_cursor;
+
+    Size new_size{old_pos.size.width + x_sign*delta.dx, old_pos.size.height + y_sign*delta.dy};
+
+    Point new_pos = top_left + left_resize*delta.dx + top_resize*delta.dy;
+
+
+    auto const& surface_info = tools->info_for(surface);
+
+    surface_info.constrain_resize(surface, new_pos, new_size, left_resize, top_resize, bounds);
+
+    apply_resize(surface, surface_info.titlebar, new_pos, new_size);
+
+    return true;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::apply_resize(
+    std::shared_ptr<ms::Surface> const& surface,
+    std::shared_ptr<ms::Surface> const& titlebar,
+    Point const& new_pos,
+    Size const& new_size) const
+{
+    if (titlebar)
+        titlebar->resize({new_size.width, Height{title_bar_height}});
+
+    surface->resize(new_size);
+
+    move_tree(surface, new_pos-surface->top_left());
+}
+
+bool me::CanonicalWindowManagerPolicyCopy::drag(std::shared_ptr<ms::Surface> surface, Point to, Point from, Rectangle /*bounds*/)
+{
+    if (!surface)
+        return false;
+
+    if (!surface->input_area_contains(from) && !tools->info_for(surface).titlebar)
+        return false;
+
+    auto movement = to - from;
+
+    // placeholder - constrain onscreen
+
+    switch (tools->info_for(surface).state)
+    {
+    case mir_surface_state_restored:
+        break;
+
+    // "A vertically maximised surface is anchored to the top and bottom of
+    // the available workspace and can have any width."
+    case mir_surface_state_vertmaximized:
+        movement.dy = DeltaY(0);
+        break;
+
+    // "A horizontally maximised surface is anchored to the left and right of
+    // the available workspace and can have any height"
+    case mir_surface_state_horizmaximized:
+        movement.dx = DeltaX(0);
+        break;
+
+    // "A maximised surface is anchored to the top, bottom, left and right of the
+    // available workspace. For example, if the launcher is always-visible then
+    // the left-edge of the surface is anchored to the right-edge of the launcher."
+    case mir_surface_state_maximized:
+    case mir_surface_state_fullscreen:
+    default:
+        return true;
+    }
+
+    move_tree(surface, movement);
+
+    return true;
+}
+
+void me::CanonicalWindowManagerPolicyCopy::move_tree(std::shared_ptr<ms::Surface> const& root, Displacement movement) const
+{
+    root->move_to(root->top_left() + movement);
+
+    for (auto const& child: tools->info_for(root).children)
+    {
+        move_tree(child.lock(), movement);
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_canonical_window_manager.h	2016-01-20 19:52:54 +0000
@@ -0,0 +1,132 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_
+
+#include "server_example_basic_window_manager.h"
+
+#include "mir/geometry/displacement.h"
+
+#include <atomic>
+#include <set>
+
+///\example server_example_canonical_window_manager.h
+// Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
+
+namespace mir
+{
+namespace shell { class DisplayLayout; }
+namespace examples
+{
+// standard window management algorithm:
+//  o Switch apps: tap or click on the corresponding tile
+//  o Move window: Alt-leftmousebutton drag (three finger drag)
+//  o Resize window: Alt-middle_button drag (two finger drag)
+//  o Maximize/restore current window (to display size): Alt-F11
+//  o Maximize/restore current window (to display height): Shift-F11
+//  o Maximize/restore current window (to display width): Ctrl-F11
+//  o client requests to maximize, vertically maximize & restore
+class CanonicalWindowManagerPolicyCopy  : public WindowManagementPolicy
+{
+public:
+
+    explicit CanonicalWindowManagerPolicyCopy(
+        WindowManagerTools* const tools,
+        std::shared_ptr<shell::DisplayLayout> const& display_layout);
+
+    void click(geometry::Point cursor);
+
+    void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void resize(geometry::Point cursor);
+
+    auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+    -> scene::SurfaceCreationParameters;
+
+    void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications);
+
+    void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface);
+
+    int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value);
+
+    void drag(geometry::Point cursor);
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event);
+
+    bool handle_touch_event(MirTouchEvent const* event);
+
+    bool handle_pointer_event(MirPointerEvent const* event);
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface);
+
+    void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_map,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build);
+
+private:
+    static const int modifier_mask =
+        mir_input_event_modifier_alt |
+        mir_input_event_modifier_shift |
+        mir_input_event_modifier_sym |
+        mir_input_event_modifier_ctrl |
+        mir_input_event_modifier_meta;
+
+    void toggle(MirSurfaceState state);
+
+    // "Mir and Unity: Surfaces, input, and displays (v0.3)" talks about active
+    //  *window*,but Mir really only understands surfaces
+    void select_active_surface(std::shared_ptr<scene::Surface> const& surface);
+    auto active_surface() const -> std::shared_ptr<scene::Surface>;
+
+    bool resize(std::shared_ptr<scene::Surface> const& surface, geometry::Point cursor, geometry::Point old_cursor, geometry::Rectangle bounds);
+    bool drag(std::shared_ptr<scene::Surface> surface, geometry::Point to, geometry::Point from, geometry::Rectangle bounds);
+    void move_tree(std::shared_ptr<scene::Surface> const& root, geometry::Displacement movement) const;
+    void apply_resize(
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        std::shared_ptr<mir::scene::Surface> const& titlebar,
+        geometry::Point const& new_pos,
+        geometry::Size const& new_size) const;
+
+    WindowManagerTools* const tools;
+    std::shared_ptr<shell::DisplayLayout> const display_layout;
+
+    geometry::Rectangle display_area;
+    geometry::Point old_cursor{};
+    std::weak_ptr<scene::Surface> active_surface_;
+    using FullscreenSurfaces = std::set<std::weak_ptr<scene::Surface>, std::owner_less<std::weak_ptr<scene::Surface>>>;
+
+    FullscreenSurfaces fullscreen_surfaces;
+};
+}
+}
+
+#endif /* MIR_EXAMPLE_CANONICAL_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp'
--- src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.cpp	2016-01-20 19:52:54 +0000
@@ -0,0 +1,640 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_tiling_window_manager.h"
+
+#include "mir/scene/session.h"
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/surface_specification.h"
+#include "mir/shell/surface_stack.h"
+#include "mir/shell/surface_ready_observer.h"
+#include "mir/geometry/displacement.h"
+
+#include <linux/input.h>
+#include <csignal>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+namespace mf = mir::frontend;
+using namespace mir::geometry;
+
+///\example server_example_tiling_window_manager.cpp
+/// Demonstrate implementing a simple tiling algorithm
+
+me::TilingWindowManagerPolicy::TilingWindowManagerPolicy(WindowManagerTools* const tools) :
+    tools{tools}
+{
+}
+
+void me::TilingWindowManagerPolicy::click(Point cursor)
+{
+    auto const session = session_under(cursor);
+    auto const surface = tools->surface_at(cursor);
+    select_active_surface(session, surface);
+}
+
+void me::TilingWindowManagerPolicy::handle_session_info_updated(SessionInfoMap& session_info, Rectangles const& displays)
+{
+    update_tiles(session_info, displays);
+}
+
+void me::TilingWindowManagerPolicy::handle_displays_updated(SessionInfoMap& session_info, Rectangles const& displays)
+{
+    update_tiles(session_info, displays);
+}
+
+void me::TilingWindowManagerPolicy::resize(Point cursor)
+{
+    if (auto const session = session_under(cursor))
+    {
+        if (session == session_under(old_cursor))
+        {
+            if (auto const surface = select_active_surface(session, tools->surface_at(old_cursor)))
+            {
+                resize(surface, cursor, old_cursor, tools->info_for(session).tile);
+            }
+        }
+    }
+}
+
+auto me::TilingWindowManagerPolicy::handle_place_new_surface(
+    std::shared_ptr<ms::Session> const& session,
+    ms::SurfaceCreationParameters const& request_parameters)
+-> ms::SurfaceCreationParameters
+{
+    auto parameters = request_parameters;
+
+    Rectangle const& tile = tools->info_for(session).tile;
+    parameters.top_left = parameters.top_left + (tile.top_left - Point{0, 0});
+
+    if (auto const parent = parameters.parent.lock())
+    {
+        auto const width = parameters.size.width.as_int();
+        auto const height = parameters.size.height.as_int();
+
+        if (parameters.aux_rect.is_set() && parameters.edge_attachment.is_set())
+        {
+            auto const edge_attachment = parameters.edge_attachment.value();
+            auto const aux_rect = parameters.aux_rect.value();
+            auto const parent_top_left = parent->top_left();
+            auto const top_left = aux_rect.top_left     -Point{} + parent_top_left;
+            auto const top_right= aux_rect.top_right()  -Point{} + parent_top_left;
+            auto const bot_left = aux_rect.bottom_left()-Point{} + parent_top_left;
+
+            if (edge_attachment & mir_edge_attachment_vertical)
+            {
+                if (tile.contains(top_right + Displacement{width, height}))
+                {
+                    parameters.top_left = top_right;
+                }
+                else if (tile.contains(top_left + Displacement{-width, height}))
+                {
+                    parameters.top_left = top_left + Displacement{-width, 0};
+                }
+            }
+
+            if (edge_attachment & mir_edge_attachment_horizontal)
+            {
+                if (tile.contains(bot_left + Displacement{width, height}))
+                {
+                    parameters.top_left = bot_left;
+                }
+                else if (tile.contains(top_left + Displacement{width, -height}))
+                {
+                    parameters.top_left = top_left + Displacement{0, -height};
+                }
+            }
+        }
+        else
+        {
+            auto const parent_top_left = parent->top_left();
+            auto const centred = parent_top_left
+                                 + 0.5*(as_displacement(parent->size()) - as_displacement(parameters.size))
+                                 - DeltaY{(parent->size().height.as_int()-height)/6};
+
+            parameters.top_left = centred;
+        }
+    }
+
+    clip_to_tile(parameters, tile);
+    return parameters;
+}
+
+void me::TilingWindowManagerPolicy::generate_decorations_for(
+    std::shared_ptr<ms::Session> const&,
+    std::shared_ptr<ms::Surface> const&,
+    SurfaceInfoMap&,
+    std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const&, ms::SurfaceCreationParameters const&)> const&)
+{
+}
+
+void me::TilingWindowManagerPolicy::handle_new_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<ms::Surface> const& surface)
+{
+    tools->info_for(session).surfaces.push_back(surface);
+
+    auto& surface_info = tools->info_for(surface);
+    if (auto const parent = surface_info.parent.lock())
+    {
+        tools->info_for(parent).children.push_back(surface);
+    }
+
+    if (surface_info.can_be_active())
+    {
+        surface->add_observer(std::make_shared<shell::SurfaceReadyObserver>(
+            [this](std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
+                { select_active_surface(session, surface); },
+            session,
+            surface));
+    }
+}
+
+void me::TilingWindowManagerPolicy::handle_modify_surface(
+    std::shared_ptr<scene::Session> const& /*session*/,
+    std::shared_ptr<scene::Surface> const& surface,
+    shell::SurfaceSpecification const& modifications)
+{
+    if (modifications.name.is_set())
+        surface->rename(modifications.name.value());
+}
+
+void me::TilingWindowManagerPolicy::handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+{
+    auto& info = tools->info_for(surface);
+
+    if (auto const parent = info.parent.lock())
+    {
+        auto& siblings = tools->info_for(parent).children;
+
+        for (auto i = begin(siblings); i != end(siblings); ++i)
+        {
+            if (surface.lock() == i->lock())
+            {
+                siblings.erase(i);
+                break;
+            }
+        }
+    }
+
+    auto& surfaces = tools->info_for(session).surfaces;
+
+    for (auto i = begin(surfaces); i != end(surfaces); ++i)
+    {
+        if (surface.lock() == i->lock())
+        {
+            surfaces.erase(i);
+            break;
+        }
+    }
+
+    session->destroy_surface(surface);
+
+    if (surfaces.empty() && session == tools->focused_session())
+    {
+        tools->focus_next_session();
+        select_active_surface(tools->focused_session(), tools->focused_surface());
+    }
+}
+
+int me::TilingWindowManagerPolicy::handle_set_state(std::shared_ptr<ms::Surface> const& surface, MirSurfaceState value)
+{
+    auto& info = tools->info_for(surface);
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+    case mir_surface_state_maximized:
+    case mir_surface_state_vertmaximized:
+    case mir_surface_state_horizmaximized:
+        break;
+
+    default:
+        return info.state;
+    }
+
+    if (info.state == mir_surface_state_restored)
+    {
+        info.restore_rect = {surface->top_left(), surface->size()};
+    }
+
+    if (info.state == value)
+    {
+        return info.state;
+    }
+
+    auto const& tile = tools->info_for(info.session).tile;
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+        surface->resize(info.restore_rect.size);
+        drag(surface, info.restore_rect.top_left, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_maximized:
+        surface->resize(tile.size);
+        drag(surface, tile.top_left, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_horizmaximized:
+        surface->resize({tile.size.width, info.restore_rect.size.height});
+        drag(surface, {tile.top_left.x, info.restore_rect.top_left.y}, surface->top_left(), tile);
+        break;
+
+    case mir_surface_state_vertmaximized:
+        surface->resize({info.restore_rect.size.width, tile.size.height});
+        drag(surface, {info.restore_rect.top_left.x, tile.top_left.y}, surface->top_left(), tile);
+        break;
+
+    default:
+        break;
+    }
+
+    return info.state = value;
+}
+
+void me::TilingWindowManagerPolicy::drag(Point cursor)
+{
+    if (auto const session = session_under(cursor))
+    {
+        if (session == session_under(old_cursor))
+        {
+            if (auto const surface = select_active_surface(session, tools->surface_at(old_cursor)))
+            {
+                drag(surface, cursor, old_cursor, tools->info_for(session).tile);
+            }
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::handle_raise_surface(
+    std::shared_ptr<ms::Session> const& session,
+    std::shared_ptr<ms::Surface> const& surface)
+{
+    select_active_surface(session, surface);
+}
+
+bool me::TilingWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
+{
+    auto const action = mir_keyboard_event_action(event);
+    auto const scan_code = mir_keyboard_event_scan_code(event);
+    auto const modifiers = mir_keyboard_event_modifiers(event) & modifier_mask;
+
+    if (action == mir_keyboard_action_down && scan_code == KEY_F11)
+    {
+        switch (modifiers & modifier_mask)
+        {
+        case mir_input_event_modifier_alt:
+            toggle(mir_surface_state_maximized);
+            return true;
+
+        case mir_input_event_modifier_shift:
+            toggle(mir_surface_state_vertmaximized);
+            return true;
+
+        case mir_input_event_modifier_ctrl:
+            toggle(mir_surface_state_horizmaximized);
+            return true;
+
+        default:
+            break;
+        }
+    }
+    else if (action == mir_keyboard_action_down && scan_code == KEY_F4)
+    {
+        if (auto const session = tools->focused_session())
+        {
+            switch (modifiers & modifier_mask)
+            {
+            case mir_input_event_modifier_alt:
+                kill(session->process_id(), SIGTERM);
+                return true;
+
+            case mir_input_event_modifier_ctrl:
+                if (auto const surf = session->default_surface())
+                {
+                    surf->request_client_surface_close();
+                    return true;
+                }
+
+            default:
+                break;
+            }
+        }
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_TAB)
+    {
+        tools->focus_next_session();
+        select_active_surface(tools->focused_session(), tools->focused_surface());
+
+        return true;
+    }
+    else if (action == mir_keyboard_action_down &&
+            modifiers == mir_input_event_modifier_alt &&
+            scan_code == KEY_GRAVE)
+    {
+        if (auto const prev = tools->focused_surface())
+        {
+            if (auto const app = tools->focused_session())
+                if (auto const surface = app->surface_after(prev))
+                {
+                    select_active_surface(app, surface);
+                }
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+bool me::TilingWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
+{
+    auto const count = mir_touch_event_point_count(event);
+
+    long total_x = 0;
+    long total_y = 0;
+
+    for (auto i = 0U; i != count; ++i)
+    {
+        total_x += mir_touch_event_axis_value(event, i, mir_touch_axis_x);
+        total_y += mir_touch_event_axis_value(event, i, mir_touch_axis_y);
+    }
+
+    Point const cursor{total_x/count, total_y/count};
+
+    bool is_drag = true;
+    for (auto i = 0U; i != count; ++i)
+    {
+        switch (mir_touch_event_action(event, i))
+        {
+        case mir_touch_action_up:
+            return false;
+
+        case mir_touch_action_down:
+            is_drag = false;
+
+        case mir_touch_action_change:
+            continue;
+        }
+    }
+
+    bool consumes_event = false;
+    if (is_drag)
+    {
+        switch (count)
+        {
+        case 2:
+            resize(cursor);
+            consumes_event = true;
+            break;
+
+        case 3:
+            drag(cursor);
+            consumes_event = true;
+            break;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+bool me::TilingWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
+{
+    auto const action = mir_pointer_event_action(event);
+    auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
+    Point const cursor{
+        mir_pointer_event_axis_value(event, mir_pointer_axis_x),
+        mir_pointer_event_axis_value(event, mir_pointer_axis_y)};
+
+    bool consumes_event = false;
+
+    if (action == mir_pointer_action_button_down)
+    {
+        click(cursor);
+    }
+    else if (action == mir_pointer_action_motion &&
+             modifiers == mir_input_event_modifier_alt)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            drag(cursor);
+            consumes_event = true;
+        }
+        else if (mir_pointer_event_button_state(event, mir_pointer_button_tertiary))
+        {
+            resize(cursor);
+            consumes_event = true;
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+void me::TilingWindowManagerPolicy::toggle(MirSurfaceState state)
+{
+    if (auto const session = tools->focused_session())
+    {
+        if (auto const surface = session->default_surface())
+        {
+            if (surface->state() == state)
+                state = mir_surface_state_restored;
+
+            auto const value = handle_set_state(surface, MirSurfaceState(state));
+            surface->configure(mir_surface_attrib_state, value);
+        }
+    }
+}
+
+std::shared_ptr<ms::Session> me::TilingWindowManagerPolicy::session_under(Point position)
+{
+    return tools->find_session([&](SessionInfo const& info) { return info.tile.contains(position);});
+}
+
+void me::TilingWindowManagerPolicy::update_tiles(
+    SessionInfoMap& session_info,
+    Rectangles const& displays)
+{
+    if (session_info.size() < 1 || displays.size() < 1) return;
+
+    auto const sessions = session_info.size();
+
+    auto const bounding_rect = displays.bounding_rectangle();
+
+    auto const total_width  = bounding_rect.size.width.as_int();
+    auto const total_height = bounding_rect.size.height.as_int();
+
+    auto index = 0;
+
+    for (auto& info : session_info)
+    {
+        auto const x = (total_width*index)/sessions;
+        ++index;
+        auto const dx = (total_width*index)/sessions - x;
+
+        auto const old_tile = info.second.tile;
+        Rectangle const new_tile{{x, 0}, {dx, total_height}};
+
+        update_surfaces(info.first, old_tile, new_tile);
+
+        info.second.tile = new_tile;
+    }
+}
+
+void me::TilingWindowManagerPolicy::update_surfaces(std::weak_ptr<ms::Session> const& session, Rectangle const& old_tile, Rectangle const& new_tile)
+{
+    auto displacement = new_tile.top_left - old_tile.top_left;
+    auto& info = tools->info_for(session);
+
+    for (auto const& ps : info.surfaces)
+    {
+        if (auto const surface = ps.lock())
+        {
+            auto const old_pos = surface->top_left();
+            surface->move_to(old_pos + displacement);
+
+            fit_to_new_tile(*surface, old_tile, new_tile);
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::clip_to_tile(ms::SurfaceCreationParameters& parameters, Rectangle const& tile)
+{
+    auto const displacement = parameters.top_left - tile.top_left;
+
+    auto width = std::min(tile.size.width.as_int()-displacement.dx.as_int(), parameters.size.width.as_int());
+    auto height = std::min(tile.size.height.as_int()-displacement.dy.as_int(), parameters.size.height.as_int());
+
+    parameters.size = Size{width, height};
+}
+
+void me::TilingWindowManagerPolicy::fit_to_new_tile(ms::Surface& surface, Rectangle const& old_tile, Rectangle const& new_tile)
+{
+    auto const displacement = surface.top_left() - new_tile.top_left;
+
+    // For now just scale if was filling width/height of tile
+    auto const old_size = surface.size();
+    auto const scaled_width = old_size.width == old_tile.size.width ? new_tile.size.width : old_size.width;
+    auto const scaled_height = old_size.height == old_tile.size.height ? new_tile.size.height : old_size.height;
+
+    auto width = std::min(new_tile.size.width.as_int()-displacement.dx.as_int(), scaled_width.as_int());
+    auto height = std::min(new_tile.size.height.as_int()-displacement.dy.as_int(), scaled_height.as_int());
+
+    surface.resize({width, height});
+}
+
+void me::TilingWindowManagerPolicy::drag(std::shared_ptr<ms::Surface> surface, Point to, Point from, Rectangle bounds)
+{
+    if (surface && surface->input_area_contains(from))
+    {
+        auto movement = to - from;
+
+        constrained_move(surface, movement, bounds);
+
+        for (auto const& child: tools->info_for(surface).children)
+        {
+            auto move = movement;
+            constrained_move(child.lock(), move, bounds);
+        }
+    }
+}
+
+void me::TilingWindowManagerPolicy::constrained_move(
+    std::shared_ptr<scene::Surface> const& surface,
+    Displacement& movement,
+    Rectangle const& bounds)
+{
+    auto const top_left = surface->top_left();
+    auto const surface_size = surface->size();
+    auto const bottom_right = top_left + as_displacement(surface_size);
+
+    if (movement.dx < DeltaX{0})
+            movement.dx = std::max(movement.dx, (bounds.top_left - top_left).dx);
+
+    if (movement.dy < DeltaY{0})
+            movement.dy = std::max(movement.dy, (bounds.top_left - top_left).dy);
+
+    if (movement.dx > DeltaX{0})
+            movement.dx = std::min(movement.dx, (bounds.bottom_right() - bottom_right).dx);
+
+    if (movement.dy > DeltaY{0})
+            movement.dy = std::min(movement.dy, (bounds.bottom_right() - bottom_right).dy);
+
+    auto new_pos = surface->top_left() + movement;
+
+    surface->move_to(new_pos);
+}
+
+void me::TilingWindowManagerPolicy::resize(std::shared_ptr<ms::Surface> surface, Point cursor, Point old_cursor, Rectangle bounds)
+{
+    if (surface && surface->input_area_contains(old_cursor))
+    {
+        auto const top_left = surface->top_left();
+
+        auto const old_displacement = old_cursor - top_left;
+        auto const new_displacement = cursor - top_left;
+
+        auto const scale_x = new_displacement.dx.as_float()/std::max(1.0f, old_displacement.dx.as_float());
+        auto const scale_y = new_displacement.dy.as_float()/std::max(1.0f, old_displacement.dy.as_float());
+
+        if (scale_x <= 0.0f || scale_y <= 0.0f) return;
+
+        auto const old_size = surface->size();
+        Size new_size{scale_x*old_size.width, scale_y*old_size.height};
+
+        auto const size_limits = as_size(bounds.bottom_right() - top_left);
+
+        if (new_size.width > size_limits.width)
+            new_size.width = size_limits.width;
+
+        if (new_size.height > size_limits.height)
+            new_size.height = size_limits.height;
+
+        surface->resize(new_size);
+    }
+}
+
+std::shared_ptr<ms::Surface> me::TilingWindowManagerPolicy::select_active_surface(std::shared_ptr<ms::Session> const& session, std::shared_ptr<scene::Surface> const& surface)
+{
+    if (!surface)
+    {
+        tools->set_focus_to({}, {});
+        return surface;
+    }
+
+    auto const& info_for = tools->info_for(surface);
+
+    if (info_for.can_be_active())
+    {
+        tools->set_focus_to(session, surface);
+        tools->raise_tree(surface);
+        return surface;
+    }
+    else
+    {
+        // Cannot have input focus - try the parent
+        if (auto const parent = info_for.parent.lock())
+            return select_active_surface(session, parent);
+
+        return {};
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h'
--- src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_tiling_window_manager.h	2016-01-20 19:52:54 +0000
@@ -0,0 +1,124 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_
+#define MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_
+
+#include "server_example_basic_window_manager.h"
+
+///\example server_example_tiling_window_manager.h
+/// Demonstrate implementing a simple tiling algorithm
+
+namespace mir
+{
+namespace examples
+{
+// simple tiling algorithm:
+//  o Switch apps: tap or click on the corresponding tile
+//  o Move window: Alt-leftmousebutton drag (three finger drag)
+//  o Resize window: Alt-middle_button drag (two finger drag)
+//  o Maximize/restore current window (to tile size): Alt-F11
+//  o Maximize/restore current window (to tile height): Shift-F11
+//  o Maximize/restore current window (to tile width): Ctrl-F11
+//  o client requests to maximize, vertically maximize & restore
+class TilingWindowManagerPolicy : public WindowManagementPolicy
+{
+public:
+    explicit TilingWindowManagerPolicy(WindowManagerTools* const tools);
+
+    void click(geometry::Point cursor);
+
+    void handle_session_info_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void handle_displays_updated(SessionInfoMap& session_info, geometry::Rectangles const& displays);
+
+    void resize(geometry::Point cursor);
+
+    auto handle_place_new_surface(
+        std::shared_ptr<scene::Session> const& session,
+        scene::SurfaceCreationParameters const& request_parameters)
+    -> scene::SurfaceCreationParameters;
+
+    void handle_new_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    void handle_modify_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface,
+        shell::SurfaceSpecification const& modifications);
+
+    void handle_delete_surface(std::shared_ptr<scene::Session> const& session, std::weak_ptr<scene::Surface> const& surface);
+
+    int handle_set_state(std::shared_ptr<scene::Surface> const& surface, MirSurfaceState value);
+
+    void drag(geometry::Point cursor);
+
+    bool handle_keyboard_event(MirKeyboardEvent const* event);
+
+    bool handle_touch_event(MirTouchEvent const* event);
+
+    bool handle_pointer_event(MirPointerEvent const* event);
+
+    void handle_raise_surface(
+        std::shared_ptr<scene::Session> const& session,
+        std::shared_ptr<scene::Surface> const& surface);
+
+    void generate_decorations_for(
+        std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface,
+        SurfaceInfoMap& surface_info,
+        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const&, scene::SurfaceCreationParameters const&)> const& build);
+
+private:
+    static const int modifier_mask =
+        mir_input_event_modifier_alt |
+        mir_input_event_modifier_shift |
+        mir_input_event_modifier_sym |
+        mir_input_event_modifier_ctrl |
+        mir_input_event_modifier_meta;
+
+    void toggle(MirSurfaceState state);
+
+    std::shared_ptr<scene::Session> session_under(geometry::Point position);
+
+    void update_tiles(
+        SessionInfoMap& session_info,
+        geometry::Rectangles const& displays);
+
+    void update_surfaces(std::weak_ptr<scene::Session> const& session, geometry::Rectangle const& old_tile, geometry::Rectangle const& new_tile);
+
+    static void clip_to_tile(scene::SurfaceCreationParameters& parameters, geometry::Rectangle const& tile);
+
+    static void fit_to_new_tile(scene::Surface& surface, geometry::Rectangle const& old_tile, geometry::Rectangle const& new_tile);
+
+    void drag(std::shared_ptr<scene::Surface> surface, geometry::Point to, geometry::Point from, geometry::Rectangle bounds);
+
+    static void resize(std::shared_ptr<scene::Surface> surface, geometry::Point cursor, geometry::Point old_cursor, geometry::Rectangle bounds);
+
+    static void constrained_move(std::shared_ptr<scene::Surface> const& surface, geometry::Displacement& movement, geometry::Rectangle const& bounds);
+
+    std::shared_ptr<scene::Surface> select_active_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface);
+
+    WindowManagerTools* const tools;
+
+    geometry::Point old_cursor{};
+};
+
+using TilingWindowManager = WindowManagerBuilder<TilingWindowManagerPolicy>;
+}
+}
+
+#endif /* MIR_EXAMPLE_TILING_WINDOW_MANAGER_H_ */

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management.cpp'
--- src/platforms/mirserver/wm-wip/server_example_window_management.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management.cpp	2016-01-20 19:52:54 +0000
@@ -0,0 +1,155 @@
+/*
+ * Copyright © 2014 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_window_management.h"
+
+#include "server_example_tiling_window_manager.h"
+#include "server_example_canonical_window_manager.h"
+
+#include "mir/abnormal_exit.h"
+#include "mir/server.h"
+#include "mir/input/composite_event_filter.h"
+#include "mir/options/option.h"
+#include "mir/scene/session.h"
+#include "mir/scene/surface_creation_parameters.h"
+#include "mir/shell/display_layout.h"
+#include "mir/shell/system_compositor_window_manager.h"
+
+namespace me = mir::examples;
+namespace mf = mir::frontend;
+namespace mg = mir::graphics;
+namespace mi = mir::input;
+namespace ms = mir::scene;
+namespace msh = mir::shell;
+using namespace mir::geometry;
+
+///\example server_example_window_management.cpp
+/// Demonstrate introducing a window management strategy
+
+namespace
+{
+char const* const wm_option = "window-manager";
+char const* const wm_description = "window management strategy [{tiling|fullscreen|canonical|system-compositor}]";
+
+char const* const wm_tiling = "tiling";
+char const* const wm_fullscreen = "fullscreen";
+char const* const wm_canonical = "canonical";
+char const* const wm_system_compositor = "system-compositor";
+
+// Very simple - make every surface fullscreen
+class FullscreenWindowManagerPolicy  : public me::WindowManagementPolicy
+{
+public:
+    FullscreenWindowManagerPolicy(me::WindowManagerTools* const /*tools*/, std::shared_ptr<msh::DisplayLayout> const& display_layout) :
+        display_layout{display_layout} {}
+
+    void handle_session_info_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/) {}
+
+    void handle_displays_updated(SessionInfoMap& /*session_info*/, Rectangles const& /*displays*/) {}
+
+    auto handle_place_new_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        ms::SurfaceCreationParameters const& request_parameters)
+    -> ms::SurfaceCreationParameters
+    {
+        auto placed_parameters = request_parameters;
+
+        Rectangle rect{request_parameters.top_left, request_parameters.size};
+        display_layout->size_to_output(rect);
+        placed_parameters.size = rect.size;
+
+        return placed_parameters;
+    }
+    void handle_modify_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        std::shared_ptr<ms::Surface> const& /*surface*/,
+        msh::SurfaceSpecification const& /*modifications*/)
+    {
+    }
+
+    void handle_new_surface(std::shared_ptr<ms::Session> const& /*session*/, std::shared_ptr<ms::Surface> const& /*surface*/)
+    {
+    }
+
+    void handle_delete_surface(std::shared_ptr<ms::Session> const& session, std::weak_ptr<ms::Surface> const& surface)
+        { session->destroy_surface(surface); }
+
+    int handle_set_state(std::shared_ptr<ms::Surface> const& /*surface*/, MirSurfaceState value)
+        { return value; }
+
+    bool handle_keyboard_event(MirKeyboardEvent const* /*event*/) { return false; }
+
+    bool handle_touch_event(MirTouchEvent const* /*event*/) { return false; }
+
+    bool handle_pointer_event(MirPointerEvent const* /*event*/) { return false; }
+
+    void handle_raise_surface(
+        std::shared_ptr<ms::Session> const& /*session*/,
+        std::shared_ptr<ms::Surface> const& /*surface*/)
+    {
+    }
+
+    void generate_decorations_for(
+        std::shared_ptr<ms::Session> const&,
+        std::shared_ptr<ms::Surface> const&,
+        SurfaceInfoMap&,
+        std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const&, ms::SurfaceCreationParameters const&)> const&)
+    {
+    }
+private:
+    std::shared_ptr<msh::DisplayLayout> const display_layout;
+};
+
+}
+
+using FullscreenWindowManager = me::WindowManagerBuilder<FullscreenWindowManagerPolicy>;
+using CanonicalWindowManager = me::WindowManagerBuilder<me::CanonicalWindowManagerPolicyCopy>;
+
+void me::add_window_manager_option_to(Server& server)
+{
+    server.add_configuration_option(wm_option, wm_description, wm_canonical);
+
+    server.override_the_window_manager_builder([&server](msh::FocusController* focus_controller)
+        -> std::shared_ptr<msh::WindowManager>
+        {
+            auto const options = server.get_options();
+            auto const selection = options->get<std::string>(wm_option);
+
+            if (selection == wm_tiling)
+            {
+                return std::make_shared<TilingWindowManager>(focus_controller);
+            }
+            else if (selection == wm_fullscreen)
+            {
+                return std::make_shared<FullscreenWindowManager>(focus_controller, server.the_shell_display_layout());
+            }
+            else if (selection == wm_canonical)
+            {
+                return std::make_shared<CanonicalWindowManager>(focus_controller, server.the_shell_display_layout());
+            }
+            else if (selection == wm_system_compositor)
+            {
+                return std::make_shared<msh::SystemCompositorWindowManager>(
+                    focus_controller,
+                    server.the_shell_display_layout(),
+                    server.the_session_coordinator());
+            }
+
+            throw mir::AbnormalExit("Unknown window manager: " + selection);
+        });
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management.h'
--- src/platforms/mirserver/wm-wip/server_example_window_management.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management.h	2016-01-20 19:52:54 +0000
@@ -0,0 +1,33 @@
+/*
+ * Copyright © 2014 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
+#define MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
+
+namespace mir
+{
+class Server;
+
+namespace examples
+{
+void add_window_manager_option_to(Server& server);
+}
+} // namespace mir
+
+
+#endif // MIR_EXAMPLES_WINDOW_MANAGEMENT_H_

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp'
--- src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management_info.cpp	2016-01-20 19:52:54 +0000
@@ -0,0 +1,406 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "server_example_window_management_info.h"
+
+#include "mir/scene/surface.h"
+#include "mir/scene/surface_creation_parameters.h"
+
+#include "mir/graphics/buffer.h"
+
+#include <atomic>
+
+namespace me = mir::examples;
+namespace ms = mir::scene;
+namespace mg = mir::graphics;
+using namespace mir::geometry;
+
+me::SurfaceInfo::SurfaceInfo(
+    std::shared_ptr<scene::Session> const& session,
+    std::shared_ptr<scene::Surface> const& surface,
+    scene::SurfaceCreationParameters const& params) :
+    type{surface->type()},
+    state{surface->state()},
+    restore_rect{surface->top_left(), surface->size()},
+    session{session},
+    parent{params.parent},
+    min_width{params.min_width.is_set() ? params.min_width.value()  : Width{}},
+    min_height{params.min_height.is_set() ? params.min_height.value() : Height{}},
+    max_width{params.max_width.is_set() ? params.max_width.value() : Width{std::numeric_limits<int>::max()}},
+    max_height{params.max_height.is_set() ? params.max_height.value() : Height{std::numeric_limits<int>::max()}},
+    width_inc{params.width_inc},
+    height_inc{params.height_inc},
+    min_aspect{params.min_aspect},
+    max_aspect{params.max_aspect}
+{
+    if (params.output_id != mir::graphics::DisplayConfigurationOutputId{0})
+        output_id = params.output_id;
+}
+
+bool me::SurfaceInfo::can_be_active() const
+{
+    switch (type)
+    {
+    case mir_surface_type_normal:       /**< AKA "regular"                       */
+    case mir_surface_type_utility:      /**< AKA "floating"                      */
+    case mir_surface_type_dialog:
+    case mir_surface_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
+    case mir_surface_type_freestyle:
+    case mir_surface_type_menu:
+    case mir_surface_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
+        return true;
+
+    case mir_surface_type_gloss:
+    case mir_surface_type_tip:          /**< AKA "tooltip"                       */
+    default:
+        // Cannot have input focus
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::must_have_parent() const
+{
+    switch (type)
+    {
+    case mir_surface_type_overlay:;
+    case mir_surface_type_inputmethod:
+    case mir_surface_type_satellite:
+    case mir_surface_type_tip:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::can_morph_to(MirSurfaceType new_type) const
+{
+    switch (new_type)
+    {
+    case mir_surface_type_normal:
+    case mir_surface_type_utility:
+    case mir_surface_type_satellite:
+        switch (type)
+        {
+        case mir_surface_type_normal:
+        case mir_surface_type_utility:
+        case mir_surface_type_dialog:
+        case mir_surface_type_satellite:
+            return true;
+
+        default:
+            break;
+        }
+        break;
+
+    case mir_surface_type_dialog:
+        switch (type)
+        {
+        case mir_surface_type_normal:
+        case mir_surface_type_utility:
+        case mir_surface_type_dialog:
+        case mir_surface_type_popover:
+        case mir_surface_type_satellite:
+            return true;
+
+        default:
+            break;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return false;
+}
+
+bool me::SurfaceInfo::must_not_have_parent() const
+{
+    switch (type)
+    {
+    case mir_surface_type_normal:
+    case mir_surface_type_utility:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+bool me::SurfaceInfo::is_visible() const
+{
+    switch (state)
+    {
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        return false;
+    default:
+        break;
+    }
+    return true;
+}
+
+struct mir::examples::SurfaceInfo::StreamPainter
+{
+    virtual void paint(int) = 0;
+    virtual ~StreamPainter() = default;
+    StreamPainter() = default;
+    StreamPainter(StreamPainter const&) = delete;
+    StreamPainter& operator=(StreamPainter const&) = delete;
+};
+
+struct mir::examples::SurfaceInfo::SwappingPainter
+    : mir::examples::SurfaceInfo::StreamPainter
+{
+    SwappingPainter(std::shared_ptr<frontend::BufferStream> const& buffer_stream) :
+        buffer_stream{buffer_stream}, buffer{nullptr}
+    {
+        swap_buffers();
+    }
+
+    void swap_buffers()
+    {
+        auto const callback = [this](mir::graphics::Buffer* new_buffer)
+            {
+                buffer.store(new_buffer);
+            };
+
+        buffer_stream->swap_buffers(buffer, callback);
+    }
+
+    void paint(int intensity) override
+    {
+        if (auto const buf = buffer.load())
+        {
+            auto const format = buffer_stream->pixel_format();
+            auto const sz = buf->size().height.as_int() *
+                            buf->size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
+            std::vector<unsigned char> pixels(sz, intensity);
+            buf->write(pixels.data(), sz);
+            swap_buffers();
+        }
+    }
+
+    std::shared_ptr<frontend::BufferStream> const buffer_stream;
+    std::atomic<graphics::Buffer*> buffer;
+};
+
+struct mir::examples::SurfaceInfo::AllocatingPainter
+    : mir::examples::SurfaceInfo::StreamPainter
+{
+    AllocatingPainter(std::shared_ptr<frontend::BufferStream> const& buffer_stream, Size size) :
+        buffer_stream(buffer_stream),
+        properties({
+            size,
+            buffer_stream->pixel_format(),
+            mg::BufferUsage::software
+        }),
+        front_buffer(buffer_stream->allocate_buffer(properties)),
+        back_buffer(buffer_stream->allocate_buffer(properties))
+    {
+    }
+
+    void paint(int intensity) override
+    {
+        buffer_stream->with_buffer(back_buffer,
+            [this, intensity](graphics::Buffer& buffer)
+            {
+                auto const format = buffer.pixel_format();
+                auto const sz = buffer.size().height.as_int() *
+                                buffer.size().width.as_int() * MIR_BYTES_PER_PIXEL(format);
+                std::vector<unsigned char> pixels(sz, intensity);
+                buffer.write(pixels.data(), sz);
+                buffer_stream->swap_buffers(&buffer, [](mg::Buffer*){});
+            });
+        std::swap(front_buffer, back_buffer);
+    }
+
+    ~AllocatingPainter()
+    {
+        buffer_stream->remove_buffer(front_buffer);
+        buffer_stream->remove_buffer(back_buffer);
+    }
+
+    std::shared_ptr<frontend::BufferStream> const buffer_stream;
+    mg::BufferProperties properties;
+    mg::BufferID front_buffer; 
+    mg::BufferID back_buffer; 
+};
+
+void mir::examples::SurfaceInfo::init_titlebar(std::shared_ptr<scene::Surface> const& surface)
+{
+    auto stream = surface->primary_buffer_stream();
+    try
+    {
+        stream_painter = std::make_shared<AllocatingPainter>(stream, surface->size());
+    }
+    catch (...)
+    {
+        stream_painter = std::make_shared<SwappingPainter>(stream);
+    }
+}
+
+void mir::examples::SurfaceInfo::paint_titlebar(int intensity)
+{
+    stream_painter->paint(intensity);
+}
+
+void me::SurfaceInfo::constrain_resize(
+    std::shared_ptr<ms::Surface> const& surface,
+    Point& requested_pos,
+    Size& requested_size,
+    bool const left_resize,
+    bool const top_resize,
+    Rectangle const& /*bounds*/) const
+{
+    Point new_pos = requested_pos;
+    Size new_size = requested_size;
+
+    if (min_aspect.is_set())
+    {
+        auto const ar = min_aspect.value();
+
+        auto const error = new_size.height.as_int()*long(ar.width) - new_size.width.as_int()*long(ar.height);
+
+        if (error > 0)
+        {
+            // Add (denominator-1) to numerator to ensure rounding up
+            auto const width_correction  = (error+(ar.height-1))/ar.height;
+            auto const height_correction = (error+(ar.width-1))/ar.width;
+
+            if (width_correction < height_correction)
+            {
+                new_size.width = new_size.width + DeltaX(width_correction);
+            }
+            else
+            {
+                new_size.height = new_size.height - DeltaY(height_correction);
+            }
+        }
+    }
+
+    if (max_aspect.is_set())
+    {
+        auto const ar = max_aspect.value();
+
+        auto const error = new_size.width.as_int()*long(ar.height) - new_size.height.as_int()*long(ar.width);
+
+        if (error > 0)
+        {
+            // Add (denominator-1) to numerator to ensure rounding up
+            auto const height_correction = (error+(ar.width-1))/ar.width;
+            auto const width_correction  = (error+(ar.height-1))/ar.height;
+
+            if (width_correction < height_correction)
+            {
+                new_size.width = new_size.width - DeltaX(width_correction);
+            }
+            else
+            {
+                new_size.height = new_size.height + DeltaY(height_correction);
+            }
+        }
+    }
+
+    if (min_width > new_size.width)
+        new_size.width = min_width;
+
+    if (min_height > new_size.height)
+        new_size.height = min_height;
+
+    if (max_width < new_size.width)
+        new_size.width = max_width;
+
+    if (max_height < new_size.height)
+        new_size.height = max_height;
+
+    if (width_inc.is_set())
+    {
+        auto const width = new_size.width.as_int() - min_width.as_int();
+        auto inc = width_inc.value().as_int();
+        if (width % inc)
+            new_size.width = min_width + DeltaX{inc*(((2L*width + inc)/2)/inc)};
+    }
+
+    if (height_inc.is_set())
+    {
+        auto const height = new_size.height.as_int() - min_height.as_int();
+        auto inc = height_inc.value().as_int();
+        if (height % inc)
+            new_size.height = min_height + DeltaY{inc*(((2L*height + inc)/2)/inc)};
+    }
+
+    if (left_resize)
+        new_pos.x += new_size.width - requested_size.width;
+
+    if (top_resize)
+        new_pos.y += new_size.height - requested_size.height;
+
+    // placeholder - constrain onscreen
+
+    switch (state)
+    {
+    case mir_surface_state_restored:
+        break;
+
+        // "A vertically maximised surface is anchored to the top and bottom of
+        // the available workspace and can have any width."
+    case mir_surface_state_vertmaximized:
+        new_pos.y = surface->top_left().y;
+        new_size.height = surface->size().height;
+        break;
+
+        // "A horizontally maximised surface is anchored to the left and right of
+        // the available workspace and can have any height"
+    case mir_surface_state_horizmaximized:
+        new_pos.x = surface->top_left().x;
+        new_size.width = surface->size().width;
+        break;
+
+        // "A maximised surface is anchored to the top, bottom, left and right of the
+        // available workspace. For example, if the launcher is always-visible then
+        // the left-edge of the surface is anchored to the right-edge of the launcher."
+    case mir_surface_state_maximized:
+    default:
+        new_pos.x = surface->top_left().x;
+        new_pos.y = surface->top_left().y;
+        new_size.width = surface->size().width;
+        new_size.height = surface->size().height;
+        break;
+    }
+
+    requested_pos = new_pos;
+    requested_size = new_size;
+}
+
+bool me::SurfaceInfo::needs_titlebar(MirSurfaceType type)
+{
+    switch (type)
+    {
+    case mir_surface_type_freestyle:
+    case mir_surface_type_menu:
+    case mir_surface_type_inputmethod:
+    case mir_surface_type_gloss:
+    case mir_surface_type_tip:
+        // No decorations for these surface types
+        return false;
+    default:
+        return true;
+    }
+}

=== added file 'src/platforms/mirserver/wm-wip/server_example_window_management_info.h'
--- src/platforms/mirserver/wm-wip/server_example_window_management_info.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/wm-wip/server_example_window_management_info.h	2016-01-20 19:52:54 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H
+#define MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H
+
+#include "mir/geometry/rectangles.h"
+#include "mir/optional_value.h"
+#include "mir/shell/surface_specification.h"
+
+#include <vector>
+
+namespace mir
+{
+namespace scene { class Session; class Surface; class SurfaceCreationParameters; }
+namespace examples
+{
+struct SurfaceInfo
+{
+    SurfaceInfo(
+        std::shared_ptr <scene::Session> const& session,
+        std::shared_ptr <scene::Surface> const& surface,
+        scene::SurfaceCreationParameters const& params);
+
+    bool can_be_active() const;
+
+    bool can_morph_to(MirSurfaceType new_type) const;
+
+    bool must_have_parent() const;
+
+    bool must_not_have_parent() const;
+
+    bool is_visible() const;
+
+    static bool needs_titlebar(MirSurfaceType type);
+
+    void constrain_resize(
+        std::shared_ptr <scene::Surface> const& surface,
+        geometry::Point& requested_pos,
+        geometry::Size& requested_size,
+        const bool left_resize,
+        const bool top_resize,
+        geometry::Rectangle const& bounds) const;
+
+    MirSurfaceType type;
+    MirSurfaceState state;
+    geometry::Rectangle restore_rect;
+    std::weak_ptr <scene::Session> session;
+    std::weak_ptr <scene::Surface> parent;
+    std::vector <std::weak_ptr<scene::Surface>> children;
+    std::shared_ptr <scene::Surface> titlebar;
+    frontend::SurfaceId titlebar_id;
+    bool is_titlebar = false;
+    geometry::Width min_width;
+    geometry::Height min_height;
+    geometry::Width max_width;
+    geometry::Height max_height;
+    mir::optional_value<geometry::DeltaX> width_inc;
+    mir::optional_value<geometry::DeltaY> height_inc;
+    mir::optional_value<shell::SurfaceAspectRatio> min_aspect;
+    mir::optional_value<shell::SurfaceAspectRatio> max_aspect;
+    mir::optional_value<graphics::DisplayConfigurationOutputId> output_id;
+
+    void init_titlebar(std::shared_ptr <scene::Surface> const& surface);
+
+    void paint_titlebar(int intensity);
+
+private:
+
+    struct StreamPainter;
+    struct AllocatingPainter;
+    struct SwappingPainter;
+
+    std::shared_ptr <StreamPainter> stream_painter;
+};
+
+struct SessionInfo
+{
+    std::vector<std::weak_ptr<scene::Surface>> surfaces;
+
+    // This is only used by the TilingWindowManagerPolicy,
+    // perhaps we need a more extensible mechanism. (std::experimental::any?)
+    geometry::Rectangle tile;
+};
+}
+}
+
+#endif //MIR_SERVER_EXAMPLE_WINDOW_MANAGEMENT_INFO_H