Mir

Merge lp:~mir-team/mir/improved-tiling-window-mamagement into lp:mir

improved-tiling-window-mamagement
Merge into development-branch

Proposed by Alan Griffiths on 2015-01-09

Status:	Merged
Approved by:	Cemil Azizoglu on 2015-01-14
Approved revision:	2244
Merged at revision:	2223
Proposed branch:	lp:~mir-team/mir/improved-tiling-window-mamagement
Merge into:	lp:mir
Diff against target:	1550 lines (+1090/-305) 7 files modified doc/demo_server_controls.md (+60/-0) doc/mainpage.md (+15/-1) examples/CMakeLists.txt (+7/-0) examples/eglstateswitcher.c (+97/-0) examples/server_example_window_management.cpp (+771/-0) examples/server_example_window_management.h (+95/-0) examples/server_example_window_manager.cpp (+45/-304)
To merge this branch:	bzr merge lp:~mir-team/mir/improved-tiling-window-mamagement
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Andreas Pokorny (community)			Approve on 2015-01-14
PS Jenkins bot	continuous-integration		Approve on 2015-01-14
Cemil Azizoglu (community)			Approve on 2015-01-13
Alberto Aguirre			Approve on 2015-01-13
Alexandros Frantzis (community)			Approve on 2015-01-13
Daniel van Vugt			Needs Fixing on 2015-01-13
Robert Carr (community)			Approve on 2015-01-12
Kevin DuBois (community)		2015-01-09	Approve on 2015-01-12
Review via email: mp+245994@code.launchpad.net

Commit Message

examples: extend the mir_demo_server's TilingWindowManager into something more functional

Description of the Change

examples: extend the mir_demo_server's TilingWindowManager into something more functional

PS Jenkins bot (ps-jenkins) wrote on 2015-01-09:

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

review: Approve (continuous-integration)

Daniel van Vugt (vanvugt) wrote on 2015-01-12:

Looks like some fun.

Just a slight word of caution: When you do demonstrate fancy things in demos, it's helpful if as much of the core logic resides in Mir itself and not in the demo. So that future shells don't all need to reinvent the wheel. One of the main architectural decisions that distinguishes Mir from Wayland is that we (intend to) provide core logic for shells instead of mandating that everyone write their own each time.

Alan Griffiths (alan-griffiths) wrote on 2015-01-12:

> Looks like some fun.
>
> Just a slight word of caution: When you do demonstrate fancy things in demos,
> it's helpful if as much of the core logic resides in Mir itself and not in the
> demo. So that future shells don't all need to reinvent the wheel. One of the
> main architectural decisions that distinguishes Mir from Wayland is that we
> (intend to) provide core logic for shells instead of mandating that everyone
> write their own each time.

It is good to show that future shells are at least possible without access to internals and having this for folks to play with gives an idea of some of the pain points with the current API.

And yeah, there's PITA stuff here (that I think should be supported more directly by Mir). I intend to address that when we feel confident of the right APIs to commit to supporting.

Kevin DuBois (kdub) wrote on 2015-01-12:

LGTM. It seems useful to see what we can do (and show others what can be done) with the existing API. I hope that we would drive the public api by porting universally useful things to core mir from the examples (via acceptance tests).

review: Approve

Robert Carr (robertcarr) wrote on 2015-01-12:

LGTM. I think this provides a lot of useful guidance on how to continue refactoring core Mir components: Ill share an edited version of my thoughts from an email thread.

Investigating the me::WindowManager interface...it's easy to recognize a clump of methods:
add_session/remove_session/add_surface/remove_surface

as paralleling the mf::Shell (SessionManager) interface to some extent. Though immediately we can recognize it as a clearer distinction of responsibilities: We no longer require the 'Window Manager' to act as the Surface factory, merely a Surface controller.

I think with this mindset we can perhaps see a good refactoring of SessionManager and the SurfaceFactory hierarchy. mf::Shell could be changed to parallel this me::WindowManager interface directly, and the factory responsibilities could be given to a new interface. The mf::Shell implementation could be given responsibility for adding the surface to the scene. Not only does this sort out the strange observer based flow in this branch[1] but it simplifies things such as the PlacementStrategy...a weird wart of a controller as it stands.

[1] The pattern used here of the window manager responding to observer notifications from the scene probably does not scale...as the window manager can not enforce that it is able to respond to an observer notification to enforce the correct policy before the compositor visits the scene to paint. Thus we will eventually have to migrate it to be a true view controller.

Robert Carr (robertcarr) on 2015-01-12:

review: Approve

Robert Carr (robertcarr) wrote on 2015-01-12:

Download full text (4.0 KiB)

For purposes of conversational transparency ill share the older version of my thoughts too, though I think what I just wrote is more significantly succinct:

Hey Alan :) Thanks for leading this effort. I've been thinking about the me::WindowManager interface and how it connects to the rest of the system. I think it's a good step and more promising than surface wrapper...I think there's one sort of cleanup that should happen before its totally compelling though.

Scanning through me::WindowManager, the first methods which grab my attention are:
add_surface, remove_surface, add_session, remove_session, etc...

Then of course, I am reminded of mf::Shell and the SessionManager When you dust off those forgotten classes this flow looks kind of strange: from SessionMediator through mf::Shell which does some factory stuff and adds stuff to the scene which dispatches to some observers, observers invoke me::WindowManager which copies the session/surface map held by the mf::Shell implementation and has a grand time with the scene implementing policy. In addition to being complicated I think this is pragmatically problematic: In particular adding surfaces to the scene and then notifying the window manager seems vulnerable to races in terms of the window manager having time to act before the compositor visits the scene. Various locking strategies can solve this, but problems continue to arise as long as the window manger is the observer....

I think this is pretty easy to sort out though if we extract responsibilities from SessionManager. First we can extract the Session and Surface Factory role/roles. This factory can then be given to the session mediator. This will be a true factory and NOT responsible for notifying observers, giving focus to new surfaces, or even adding them to the scene! Now the mf::Shell interface is reshaped to look like portions of your WindowManager interface, e.g.

mf::Shell
{
add_session...
remove_session,
add_surface,.
remove_surface,
configure_surface_attribute,
resize_surface, (assuming we had client initiated resize)
etc...
}

me::WindowManager could of course implement this. This object can then add surfaces to the scene as it wishes, and manipulate them as such. Elements which are common to all window managers have a representation in the protocol, and thus will be part of this mf::Shell interface. Shell authors are free to extend this interface in their implementation class to attach additional methods (e.g. drag and resize as they exist in me::WindowManager or unity::WindowManager::start_window_carousel_for(session)).

In some ways this is a return to some of the original window management design in the sense that it proposes this object sitting in-between the front-end and scene acting as an enforcer of policy through a controller role. It features a few key differences though that I think will really clarify the code and make things easier:

1. Removal of the msh::Surface wrapper. Maybe you remember a model we used to use where msh::Surface would hold so called surface data which wasn't part of the 'inner core' e.g. SurfaceAttributes. This was to allow the implementation of surfaces which were not "Shell" surfaces and...

Cemil Azizoglu (cemil-azizoglu) wrote on 2015-01-12:

F11 key doesn't do anything for me. It was working in the previous versions, though resize, and move both work. Is it still working for you?

review: Needs Fixing

Cemil Azizoglu (cemil-azizoglu) wrote on 2015-01-12:

Also eglflash doesn't toggle for me. It comes up maximized and stays maximized - unless I resize it, then it starts toggling.

Alan Griffiths (alan-griffiths) wrote on 2015-01-12:

I guess it is confusing that eglflash comes up in a "restored" window that is the size of the tile.

On 12 Jan 2015 22:45, Cemil Azizoglu <email address hidden> wrote:
>
> Also eglflash doesn't toggle for me. It comes up maximized and stays maximized - unless I resize it, then it starts toggling.
> --
> https://code.launchpad.net/~mir-team/mir/improved-tiling-window-mamagement/+merge/245994
> Your team Mir development team is subscribed to branch lp:mir.

Chris Halse Rogers (raof) wrote on 2015-01-13:

I think I've pretty consistently said that we should implement a window manager with what we've got and then pull obviously relevant bits into Mir core over time. As such, I approve of this general approach. (Have not yet done code review)

Daniel van Vugt (vanvugt) wrote on 2015-01-13:

(1) Please don't make eglflash do anything other than flash:
158 +++ examples/eglflash.c 2015-01-09 18:07:10 +0000
164 + mir_eglapp_toggle_surface_state();

(2) These odd state transitions shouldn't be common to all eglapps. It results in such weird behaviour that it would be better placed in some kind of explicitly named mir_demo_client_shapeshifter...
114 +++ examples/eglapp.c 2015-01-09 18:07:10 +0000
120 +void mir_eglapp_toggle_surface_state(void)

(3) The class name "WindowManager" is a hack and really needs to be removed instead of reused. I've mentioned this several times over the years. Just once last year I slipped up and felt I had to implement a "WindowManager" class. But we don't and we should not.
   "Manager" like "Controller" are poorly chosen abstractions that lead to poor designs that are difficult to work with. But I'm not the only one who says so. Further reading:
   http://objology.blogspot.com.au/2011/09/one-of-best-bits-of-programming-advice.html
   http://www.benhallbenhall.com/2013/01/naming-objects-er-object-names/
I don't expect to get sufficient votes to affect change on (3) but it's important and something everyone on the team should think about.

review: Needs Fixing

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-13

2235. By Alan Griffiths on 2015-01-13: eglstateswitcher

Alan Griffiths (alan-griffiths) wrote on 2015-01-13:

> (1) Please don't make eglflash do anything other than flash:
> 158 +++ examples/eglflash.c 2015-01-09 18:07:10 +0000
> 164 + mir_eglapp_toggle_surface_state();
>
> (2) These odd state transitions shouldn't be common to all eglapps. It results
> in such weird behaviour that it would be better placed in some kind of
> explicitly named mir_demo_client_shapeshifter...
> 114 +++ examples/eglapp.c 2015-01-09 18:07:10 +0000
> 120 +void mir_eglapp_toggle_surface_state(void)

Fixed

> (3) The class name "WindowManager" is a hack and really needs to be removed
> instead of reused. I've mentioned this several times over the years. Just once
> last year I slipped up and felt I had to implement a "WindowManager" class.
> But we don't and we should not.
> "Manager" like "Controller" are poorly chosen abstractions that lead to
> poor designs that are difficult to work with. But I'm not the only one who
> says so. Further reading:
> http://objology.blogspot.com.au/2011/09/one-of-best-bits-of-programming-
> advice.html
> http://www.benhallbenhall.com/2013/01/naming-objects-er-object-names/
> I don't expect to get sufficient votes to affect change on (3) but it's
> important and something everyone on the team should think about.

I too have doubts about XXXManager, but "window manager" seems to have sufficient currency to be exempted as a "term of art".

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-13

2236. By Alan Griffiths on 2015-01-13: Avoid attempt to recursively lock

Alan Griffiths (alan-griffiths) wrote on 2015-01-13:

> F11 key doesn't do anything for me. It was working in the previous versions,
> though resize, and move both work. Is it still working for you?

Fixed

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-13

2237. By Alan Griffiths on 2015-01-13: Further reduce scope of lock
2238. By Alan Griffiths on 2015-01-13: Clearer code
2239. By Alan Griffiths on 2015-01-13: Remove redundant resizing code

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

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

review: Approve (continuous-integration)

Alexandros Frantzis (afrantzis) wrote on 2015-01-13:

Looks like a good concrete starting point to trigger further thoughts and discussions about the architecture of our scene/model and how it ties with window management.

review: Approve

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

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

review: Approve (continuous-integration)

Alberto Aguirre (albaguirre) wrote on 2015-01-13:

Does what it claims to do.

It's a good showcase of the awkward APIs the shell has to use to do simple things, which hopefully guides our future architectural changes.

review: Approve

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-13

2240. By Cemil Azizoglu on 2015-01-13: On MacBook Pro, F11 is FN+F11. So don't use function key in the mask.

Cemil Azizoglu (cemil-azizoglu) wrote on 2015-01-13:

> F11 key doesn't do anything for me. It was working in the previous versions,
> though resize, and move both work. Is it still working for you?

Fixed.

review: Approve

Robert Carr (robertcarr) wrote on 2015-01-13:

*Opens sealed envelope over suspenseful drum roll*

*Reveals prediction of review votes on this MP to shock and applause*

Thank you, thank you, I'm here all week.

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

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

review: Approve (continuous-integration)

Daniel van Vugt (vanvugt) wrote on 2015-01-14:

(4) Preferably choose key combos already familiar to users, instead of:
45 + - Resize window: *Meta-mousewheel*
Normally Alt+middle_button
46 + - Maximize/restore current window (to tile size): F11
Needs a modifier like Alt or something. Because it's good behaviour to not steal keys that apps might use themselves (e.g. F11 usually means app-initiated fullscreen).

(5) I'm a little concerned that people see this as an alternative to my current and previous proposals. They do different things of course, so remember that. My branches provide WM logic that is immediately reusable (without any effort) by any shell in half the amount of code, with test cases, and also solve future problems of metadata, behavioural overrides and minimizing the footprint of future shells that just want to override a few things.
I understand this tiling work is still acting as a thought experiment, but it appears to be on track to never be able to catch up to what I've already proposed in all those metrics. Of course, not sure, and it's just examples, so not a blocking concern yet.

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-14

2241. By Alan Griffiths on 2015-01-14: merge lp:mir

Alan Griffiths (alan-griffiths) wrote on 2015-01-14:

> (4) Preferably choose key combos already familiar to users, instead of:
> 45 + - Resize window: *Meta-mousewheel*
> Normally Alt+middle_button

I'll look into this. You mean Alt+middle_button & drag I presume?

> 46 + - Maximize/restore current window (to tile size): F11
> Needs a modifier like Alt or something. Because it's good behaviour to not
> steal keys that apps might use themselves (e.g. F11 usually means app-
> initiated fullscreen).

OK, done.

> (5) I'm a little concerned that people see this as an alternative to my
> current and previous proposals. They do different things of course, so
> remember that. My branches provide WM logic that is immediately reusable
> (without any effort) by any shell in half the amount of code, with test cases,
> and also solve future problems of metadata, behavioural overrides and
> minimizing the footprint of future shells that just want to override a few
> things.
> I understand this tiling work is still acting as a thought experiment, but
> it appears to be on track to never be able to catch up to what I've already
> proposed in all those metrics. Of course, not sure, and it's just examples, so
> not a blocking concern yet.

I agree this isn't an alternative. "Tiling" is an experiment to see how well shells can do window management through our published API. Your "alternative" proposals work use internal APIs so it isn't clear how they can be used by "future shells" (you're welcome to add options to demo_server to clarify this).

IMO both this work and yours is likely to motivate changes to the public API to make it easier to use.

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-14

2242. By Alan Griffiths on 2015-01-14: Maximize/restore current window (to tile size): F11 => Alt-F11

PS Jenkins bot (ps-jenkins) wrote on 2015-01-14:

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

review: Approve (continuous-integration)

lp:~mir-team/mir/improved-tiling-window-mamagement updated on 2015-01-14

2243. By Alan Griffiths on 2015-01-14: Alt-middle_button drag to resize
2244. By Alan Griffiths on 2015-01-14: Remove old scaling code

Alan Griffiths (alan-griffiths) wrote on 2015-01-14:

> > (4) Preferably choose key combos already familiar to users, instead of:
> > 45 + - Resize window: *Meta-mousewheel*
> > Normally Alt+middle_button
>
> I'll look into this. You mean Alt+middle_button & drag I presume?

Done

PS Jenkins bot (ps-jenkins) wrote on 2015-01-14:

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

review: Approve (continuous-integration)

Andreas Pokorny (andreas-pokorny) wrote on 2015-01-14:

nice.

http://xmonad.org/tour.html#tiling
^
If you feel the urge for a different layout/tiling strategies

review: Approve

Alan Griffiths (alan-griffiths) wrote on 2015-01-14:

> nice.
>
> http://xmonad.org/tour.html#tiling
> ^
> If you feel the urge for a different layout/tiling strategies

That can be an exercise for the interested reader. ;^)

Preview Diff

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

Subscribers

People subscribed via source and target branches

to all changes:

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === added file 'doc/demo_server_controls.md'
 --- doc/demo_server_controls.md	1970-01-01 00:00:00 +0000
 +++ doc/demo_server_controls.md	2015-01-14 12:09:57 +0000
@@ -0,0 +1,60 @@
++Demo Server {#demo_server}
++===========
++
++Mir's demo server (`mir_demo_server`) is an example of using the Mir to
++build a server. In contrast to mir_proving_server (see \ref demo_shell_controls)
++it uses only functionality supported by the public Mir API.
++
++Running Demo Server
++-------------------
++
++Remember to always run `mir_demo_server` as root on PC (not required on
++Android), as this is required for input device support (open bug
++https://bugs.launchpad.net/mir/+bug/1286252);
++
++    sudo mir_demo_server
++
++And if you're not already on the VT you wish to use, that needs to be
++specified:
++
++    sudo mir_demo_server --vt 1
++
++There are plenty more options available if you run:
++
++    mir_demo_server --help
++
++Tiling Window Manager
++---------------------
++
++One option that needs elaboration is "--window-manager tiling".
++
++This starts a (rather primitive) tiling window manager. It tracks the available
++displays and splits the available workspace into "tiles" (one per client).
++
++The following operations are supported:
++
++ - Quit (shut down the Mir server): *Ctrl-Alt-Backspace*
++ - Switch back to X: *Ctrl-Alt-F7*
++ - Switch virtual terminals (VTs): *Ctrl-Alt-(F1-F12)*
++ - Switch apps: tap or click on the corresponding tile
++ - Move window: *Alt-leftmousebutton* drag
++ - Resize window: *Alt-middle_button* drag
++ - Maximize/restore current window (to tile size): Alt-F11
++ - Maximize/restore current window (to tile height): Shift-F11
++ - Maximize/restore current window (to tile width): Ctrl-F11
++
++For those writing client code request to set the surface attribute
++`mir_surface_attrib_state` are honoured:
++ - `mir_surface_state_restored`: restores the window
++ - `mir_surface_state_maximized`: maximizes to tile size
++ - `mir_surface_state_vertmaximized`: maximizes to tile height
++
++For a quick demo try:
++
++    sudo mir_demo_server --vt 1 --display-config sidebyside\
++     --window-manager tiling --launch bin/mir_demo_client_egltriangle\
++     --test-client bin/mir_demo_client_multiwin --test-timeout 60
++
++(Remember to unwrap the line)
++
++Want more? Log your requests at: https://bugs.launchpad.net/mir/+filebug
 === modified file 'doc/mainpage.md'
 --- doc/mainpage.md	2014-12-28 08:33:45 +0000
 +++ doc/mainpage.md	2015-01-14 12:09:57 +0000
@@ -42,6 +42,7 @@
   - \ref using_mir_on_android
   - \ref debug_for_xmir
   - \ref demo_shell_controls
++ - \ref demo_server
  Getting involved
  ----------------
@@ -81,7 +82,20 @@
  Mir server is written as a library which allows the server code to be adapted
  for bespoke applications.
-- - \subpage render_surfaces-example "render_surfaces.cpp: A simple program using the Mir library"
++ - \subpage server_example.cpp
++   "server_example.cpp: a test executable hosting the following"
++ - \subpage server_example_input_event_filter.cpp
++   "server_example_input_event_filter.cpp: provide a Quit command"
++ - \subpage server_example_display_configuration_policy.cpp
++   "server_example_display_configuration_policy.cpp: configuring display layout"
++ - \subpage server_example_input_filter.cpp
++   "server_example_input_filter.cpp: print input events to stdout"
++ - \subpage server_example_log_options.cpp
++   "server_example_log_options.cpp: replace Mir logger with glog"
++ - \subpage server_example_window_manager.cpp
++   "server_example_window_manager.cpp: How to wire up a window manager"
++ - \subpage server_example_window_management.cpp
++   "server_example_window_management.cpp: simple window management examples"
  Working on Mir code
  -------------------
 === modified file 'examples/CMakeLists.txt'
 --- examples/CMakeLists.txt	2015-01-14 08:52:38 +0000
 +++ examples/CMakeLists.txt	2015-01-14 12:09:57 +0000
@@ -23,6 +23,7 @@
    server_example_fullscreen_placement_strategy.cpp
    server_example_host_lifecycle_event.cpp
    server_example_window_manager.cpp
++  server_example_window_management.cpp
+ )
  target_link_libraries(eglapp
@@ -60,6 +61,12 @@
  target_link_libraries(mir_demo_client_cursors
    eglapp
+ )
++mir_add_wrapped_executable(mir_demo_client_eglstateswitcher
++  eglstateswitcher.c
++)
++target_link_libraries(mir_demo_client_eglstateswitcher
++  eglapp
++)
  mir_add_wrapped_executable(mir_demo_client_basic
    basic.c
 === added file 'examples/eglstateswitcher.c'
 --- examples/eglstateswitcher.c	1970-01-01 00:00:00 +0000
 +++ examples/eglstateswitcher.c	2015-01-14 12:09:57 +0000
@@ -0,0 +1,97 @@
++/*
++ * Trivial GL demo; switches surface states. Showing how simple life is with eglapp.
++ *
++ * 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/>.
++ *
++ * Author: Alan Griffiths <alan@octopull.co.uk>
++ */
++
++#include "eglapp.h"
++#include <mir_toolkit/mir_client_library.h>
++
++#include <stdio.h>
++#include <unistd.h>
++#include <GLES2/gl2.h>
++
++static void toggle_surface_state(MirSurface* const surface, MirSurfaceState* state);
++
++typedef struct Color
++{
++    GLfloat r, g, b, a;
++} Color;
++
++int main(int argc, char *argv[])
++{
++    float const opacity = mir_eglapp_background_opacity;
++    Color const orange = {0.866666667f, 0.282352941f, 0.141414141f, opacity};
++
++    unsigned int width = 120, height = 120;
++
++    if (!mir_eglapp_init(argc, argv, &width, &height))
++        return 1;
++
++    MirSurface* const surface = mir_eglapp_native_surface();
++    MirSurfaceState state = mir_surface_get_state(surface);
++
++    /* This is probably the simplest GL you can do */
++    while (mir_eglapp_running())
++    {
++        glClearColor(orange.r, orange.g, orange.b, orange.a);
++        glClear(GL_COLOR_BUFFER_BIT);
++        mir_eglapp_swap_buffers();
++        sleep(2);
++
++        toggle_surface_state(surface, &state);
++    }
++
++    mir_eglapp_shutdown();
++
++    return 0;
++}
++
++#define NEW_STATE(new_state)\
++        puts("Requesting state: " #new_state);\
++        *state = new_state
++
++void toggle_surface_state(MirSurface* const surface, MirSurfaceState* state)
++{
++    switch (*state)
++    {
++    case mir_surface_state_restored:
++        NEW_STATE(mir_surface_state_unknown);
++        break;
++
++    case mir_surface_state_minimized:
++        NEW_STATE(mir_surface_state_restored);
++        break;
++
++    case mir_surface_state_fullscreen:
++        NEW_STATE(mir_surface_state_vertmaximized);
++        break;
++
++    case mir_surface_state_maximized:
++        NEW_STATE(mir_surface_state_fullscreen);
++        break;
++
++    case mir_surface_state_vertmaximized:
++        NEW_STATE(mir_surface_state_minimized);
++        break;
++
++    default:
++        NEW_STATE(mir_surface_state_maximized);
++        break;
++    }
++    mir_surface_set_state(surface, *state);
++}
 === added file 'examples/server_example_window_management.cpp'
 --- examples/server_example_window_management.cpp	1970-01-01 00:00:00 +0000
 +++ examples/server_example_window_management.cpp	2015-01-14 12:09:57 +0000
@@ -0,0 +1,771 @@
++/*
++ * 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 <alan@octopull.co.uk>
++ */
++
++#include "server_example_window_management.h"
++#include "server_example_fullscreen_placement_strategy.h"
++
++#include "mir/abnormal_exit.h"
++#include "mir/server.h"
++#include "mir/geometry/rectangles.h"
++#include "mir/geometry/displacement.h"
++#include "mir/input/composite_event_filter.h"
++#include "mir/options/option.h"
++#include "mir/scene/session_listener.h"
++#include "mir/shell/focus_controller.h"
++
++#include <linux/input.h>
++
++#include <map>
++#include <vector>
++#include <mutex>
++
++namespace mc = mir::compositor;
++namespace me = mir::examples;
++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 simple window management strategies
++
++char const* const me::wm_option = "window-manager";
++char const* const me::wm_description = "window management strategy [{tiling|fullscreen}]";
++
++namespace
++{
++char const* const wm_tiling = "tiling";
++char const* const wm_fullscreen = "fullscreen";
++
++// Very simple - make every surface fullscreen
++class FullscreenWindowManager : public me::WindowManager, me::FullscreenPlacementStrategy
++{
++public:
++    using me::FullscreenPlacementStrategy::FullscreenPlacementStrategy;
++
++private:
++    void add_surface(std::shared_ptr<ms::Surface> const&, ms::Session*) override {}
++
++    void remove_surface(std::weak_ptr<ms::Surface> const&, ms::Session*) override {}
++
++    void add_session(std::shared_ptr<ms::Session> const&) override {}
++
++    void remove_session(std::shared_ptr<ms::Session> const&) override {}
++
++    void add_display(Rectangle const&) override {}
++
++    void remove_display(Rectangle const&) override {}
++
++    void click(Point) override {}
++
++    void drag(Point) override {}
++
++    void resize(Point) override {}
++
++    void toggle_maximized() override {}
++
++    void toggle_max_horizontal() override {}
++
++    void toggle_max_vertical() override {}
++
++    int select_attribute_value(ms::Surface const&, MirSurfaceAttrib, int requested_value) override
++        { return requested_value; }
++
++    void attribute_set(ms::Surface const&, MirSurfaceAttrib, int) override {}
++};
++
++// simple tiling algorithm:
++//  o Switch apps: tap or click on the corresponding tile
++//  o Move window: Alt-leftmousebutton drag
++//  o Resize window: Alt-middle_button 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 TilingWindowManager : public me::WindowManager
++{
++public:
++    // We can't take the msh::FocusController directly as we create a WindowManager
++    // in the_session_listener() and that is called when creating the focus controller
++    using FocusControllerFactory = std::function<std::shared_ptr<msh::FocusController>()>;
++
++    explicit TilingWindowManager(FocusControllerFactory const& focus_controller) :
++        focus_controller{focus_controller}
++    {
++    }
++
++    auto place(ms::Session const& session, ms::SurfaceCreationParameters const& request_parameters)
++    -> ms::SurfaceCreationParameters override
++    {
++        auto parameters = request_parameters;
++
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        auto const ptile = session_info.find(&session);
++        if (ptile != end(session_info))
++        {
++            Rectangle const& tile = ptile->second.tile;
++            parameters.top_left = parameters.top_left + (tile.top_left - Point{0, 0});
++
++            clip_to_tile(parameters, tile);
++        }
++
++        return parameters;
++    }
++
++    void add_surface(
++        std::shared_ptr<ms::Surface> const& surface,
++        ms::Session* session) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        session_info[session].surfaces.push_back(surface);
++        surface_info[surface].session = session_info[session].session;
++        surface_info[surface].state = SurfaceInfo::restored;
++    }
++
++    void remove_surface(
++        std::weak_ptr<ms::Surface> const& surface,
++        ms::Session* session) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        auto& surfaces = session_info[session].surfaces;
++
++        for (auto i = begin(surfaces); i != end(surfaces); ++i)
++        {
++            if (surface.lock() == i->lock())
++            {
++                surfaces.erase(i);
++                break;
++            }
++        }
++
++        surface_info.erase(surface);
++    }
++
++    void add_session(std::shared_ptr<ms::Session> const& session) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        session_info[session.get()] = session;
++        update_tiles();
++    }
++
++    void remove_session(std::shared_ptr<ms::Session> const& session) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        session_info.erase(session.get());
++        update_tiles();
++    }
++
++    void add_display(Rectangle const& area) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        displays.push_back(area);
++        update_tiles();
++    }
++
++    void remove_display(Rectangle const& area) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++        auto const i = std::find(begin(displays), end(displays), area);
++        if (i != end(displays)) displays.erase(i);
++        update_tiles();
++    }
++
++    void click(Point cursor) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++
++        if (auto const session = session_under(cursor))
++            focus_controller()->set_focus_to(session);
++
++        old_cursor = cursor;
++    }
++
++    void drag(Point cursor) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++
++        if (auto const session = session_under(cursor))
++        {
++            if (session == session_under(old_cursor))
++            {
++                auto const& info = session_info[session.get()];
++
++                if (drag(old_surface.lock(), cursor, old_cursor, info.tile))
++                {
++                    // Still dragging the same old_surface
++                }
++                else if (drag(session->default_surface(), cursor, old_cursor, info.tile))
++                {
++                    old_surface = session->default_surface();
++                }
++                else
++                {
++                    for (auto const& ps : info.surfaces)
++                    {
++                        auto const new_surface = ps.lock();
++
++                        if (drag(new_surface, cursor, old_cursor, info.tile))
++                        {
++                            old_surface = new_surface;
++                            break;
++                        }
++                    }
++                }
++            }
++        }
++
++        old_cursor = cursor;
++    }
++
++    void resize(Point cursor) override
++    {
++        std::lock_guard<decltype(mutex)> lock(mutex);
++
++        if (auto const session = session_under(cursor))
++        {
++            if (session == session_under(old_cursor))
++            {
++                auto const& info = session_info[session.get()];
++
++                if (resize(old_surface.lock(), cursor, old_cursor, info.tile))
++                {
++                    // Still dragging the same old_surface
++                }
++                else if (resize(session->default_surface(), cursor, old_cursor, info.tile))
++                {
++                    old_surface = session->default_surface();
++                }
++                else
++                {
++                    for (auto const& ps : info.surfaces)
++                    {
++                        auto const new_surface = ps.lock();
++
++                        if (resize(new_surface, cursor, old_cursor, info.tile))
++                        {
++                            old_surface = new_surface;
++                            break;
++                        }
++                    }
++                }
++            }
++        }
++
++        old_cursor = cursor;
++    }
++
++    void toggle_maximized() override
++    {
++        toggle(SurfaceInfo::maximized);
++    }
++
++    void toggle_max_horizontal() override
++    {
++        toggle(SurfaceInfo::hmax);
++    }
++
++    void toggle_max_vertical() override
++    {
++        toggle(SurfaceInfo::vmax);
++    }
++
++    int select_attribute_value(ms::Surface const&, MirSurfaceAttrib, int requested_value) override
++        { return requested_value; }
++
++    void attribute_set(ms::Surface const& surface, MirSurfaceAttrib attrib, int value) override
++    {
++        switch (attrib)
++        {
++        case mir_surface_attrib_state:
++        {
++            std::lock_guard<decltype(mutex)> lock(mutex);
++            set_state(surface, value);
++            break;
++        }
++        default:
++            break;
++        }
++    }
++
++private:
++    void update_tiles()
++    {
++        if (session_info.size() < 1 || displays.size() < 1) return;
++
++        auto const sessions = session_info.size();
++        Rectangles view;
++
++        for (auto const& display : displays)
++            view.add(display);
++
++        auto const bounding_rect = view.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 update_surfaces(ms::Session const* session, Rectangle const& old_tile, Rectangle const& new_tile)
++    {
++        auto displacement = new_tile.top_left - old_tile.top_left;
++        auto& info = session_info[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);
++            }
++        }
++    }
++
++    static void 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};
++    }
++
++    static void 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});
++    }
++
++    static bool drag(std::shared_ptr<ms::Surface> surface, Point to, Point from, Rectangle bounds)
++    {
++        if (surface && surface->input_area_contains(from))
++        {
++            auto const top_left = surface->top_left();
++            auto const surface_size = surface->size();
++            auto const bottom_right = top_left + as_displacement(surface_size);
++
++            auto movement = to - from;
++
++            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);
++            return true;
++        }
++
++        return false;
++    }
++
++    static bool 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 false;
++
++            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);
++
++            return true;
++        }
++
++        return false;
++    }
++
++    struct SurfaceInfo
++    {
++        SurfaceInfo() = default;
++        std::weak_ptr<ms::Session> session;
++        enum State { restored, maximized, hmax, vmax } state;
++        Rectangle restore_rect;
++    };
++
++    void toggle(SurfaceInfo::State state)
++    {
++        // We have to duplicate the state information into surface to notify the
++        // client. But this has to happen without holding a lock (as we are also
++        // notified via a call to attribute_set()).
++        std::function<void()> notify_client = [](){};
++
++        if (auto const focussed_session = focus_controller()->focussed_application().lock())
++        {
++            if (auto const focussed_surface = focussed_session->default_surface())
++            {
++                std::lock_guard<decltype(mutex)> lock(mutex);
++
++                auto& surface_info = this->surface_info[focussed_surface];
++
++                if (surface_info.state == state)
++                {
++                    notify_client = [focussed_surface]()
++                        {
++                            focussed_surface->configure(
++                                mir_surface_attrib_state,
++                                mir_surface_state_restored);
++                        };
++                }
++                else
++                {
++                    switch (state)
++                    {
++                    case SurfaceInfo::maximized:
++                        notify_client = [focussed_surface]()
++                            {
++                                focussed_surface->configure(
++                                    mir_surface_attrib_state,
++                                    mir_surface_state_maximized);
++                            };
++                        break;
++
++                    case SurfaceInfo::hmax:
++                    {
++                        // We have to implement this here as we can't code hmax into mir_surface_attrib_state
++                        auto const& session_info = this->session_info[focussed_session.get()];
++                        surface_info.state = state;
++                        focussed_surface->move_to({session_info.tile.top_left.x, surface_info.restore_rect.top_left.y});
++                        focussed_surface->resize({session_info.tile.size.width, surface_info.restore_rect.size.height});
++
++                        notify_client = [focussed_surface]()
++                            {
++                                focussed_surface->configure(
++                                    mir_surface_attrib_state,
++                                    mir_surface_state_unknown);
++                            };
++                        break;
++                    }
++                    case SurfaceInfo::vmax:
++                        notify_client = [focussed_surface]()
++                            {
++                                focussed_surface->configure(
++                                    mir_surface_attrib_state,
++                                    mir_surface_state_vertmaximized);
++                            };
++                        break;
++
++                    default:
++                        break;
++                    }
++                }
++            }
++        }
++
++        notify_client();
++    }
++
++    void set_state(ms::Surface const& surface, int value)
++    {
++        auto new_state = SurfaceInfo::restored;
++
++        switch (value)
++        {
++        case mir_surface_state_restored:
++            new_state = SurfaceInfo::restored;
++            break;
++
++        case mir_surface_state_maximized:
++            new_state = SurfaceInfo::maximized;
++            break;
++
++        case mir_surface_state_vertmaximized:
++            new_state = SurfaceInfo::vmax;
++            break;
++
++        default:
++            return;
++        }
++
++        for (auto& i : surface_info)
++        {
++            if (auto const sp = i.first.lock())
++            {
++                if (sp.get() == &surface)
++                {
++                    auto& surface_info = i.second;
++
++                    if (surface_info.state == SurfaceInfo::restored)
++                    {
++                        surface_info.restore_rect = {sp->top_left(), sp->size()};
++                    }
++
++                    if (surface_info.state == new_state)
++                    {
++                        return; // Nothing to do
++                    }
++
++                    auto const& session_info =
++                        this->session_info[surface_info.session.lock().get()];
++
++                    switch (new_state)
++                    {
++                    case SurfaceInfo::restored:
++                        sp->move_to(surface_info.restore_rect.top_left);
++                        sp->resize(surface_info.restore_rect.size);
++                        break;
++
++                    case SurfaceInfo::maximized:
++                        sp->move_to(session_info.tile.top_left);
++                        sp->resize(session_info.tile.size);
++                        break;
++
++                    case SurfaceInfo::hmax:
++                        sp->move_to({session_info.tile.top_left.x, surface_info.restore_rect.top_left.y});
++                        sp->resize({session_info.tile.size.width, surface_info.restore_rect.size.height});
++                        break;
++
++                    case SurfaceInfo::vmax:
++                        sp->move_to({surface_info.restore_rect.top_left.x, session_info.tile.top_left.y});
++                        sp->resize({surface_info.restore_rect.size.width, session_info.tile.size.height});
++                        break;
++                    }
++
++                    surface_info.state = new_state;
++                }
++            }
++        }
++    }
++
++    std::shared_ptr<ms::Session> session_under(Point position)
++    {
++        for(auto& info : session_info)
++        {
++            if (info.second.tile.contains(position))
++            {
++                return info.second.session.lock();
++            }
++        }
++
++        return std::shared_ptr<ms::Session>{};
++    }
++
++    struct SessionInfo
++    {
++        SessionInfo() = default;
++        SessionInfo& operator=(std::weak_ptr<ms::Session> const& session)
++        {
++            this->session = session;
++            surfaces.clear();
++            return *this;
++        }
++        std::weak_ptr<ms::Session> session;
++        Rectangle tile;
++        std::vector<std::weak_ptr<ms::Surface>> surfaces;
++    };
++
++    FocusControllerFactory const focus_controller;
++
++    std::mutex mutex;
++    std::vector<Rectangle> displays;
++
++    std::map<ms::Session const*, SessionInfo> session_info;
++    std::map<std::weak_ptr<ms::Surface>, SurfaceInfo, std::owner_less<std::weak_ptr<ms::Surface>>> surface_info;
++
++    Point old_cursor{};
++    std::weak_ptr<ms::Surface> old_surface;
++};
++}
++
++class me::EventTracker : public mi::EventFilter
++{
++public:
++    explicit EventTracker(std::shared_ptr<me::WindowManager> const& window_manager) :
++        window_manager{window_manager} {}
++
++    bool handle(MirEvent const& event) override
++    {
++        switch (event.type)
++        {
++        case mir_event_type_key:
++            return handle_key_event(event.key);
++
++        case mir_event_type_motion:
++            return handle_motion_event(event.motion);
++
++        default:
++            return false;
++        }
++    }
++
++private:
++    bool handle_key_event(MirKeyEvent const& event)
++    {
++        static const int modifier_mask =
++            mir_key_modifier_alt |
++            mir_key_modifier_shift |
++            mir_key_modifier_sym |
++            mir_key_modifier_ctrl |
++            mir_key_modifier_meta;
++
++        if (event.action == mir_key_action_down &&
++            event.scan_code == KEY_F11)
++        {
++            if (auto const wm = window_manager.lock())
++            switch (event.modifiers & modifier_mask)
++            {
++            case mir_key_modifier_alt:
++                wm->toggle_maximized();
++                return true;
++
++            case mir_key_modifier_shift:
++                wm->toggle_max_vertical();
++                return true;
++
++            case mir_key_modifier_ctrl:
++                wm->toggle_max_horizontal();
++                return true;
++
++            default:
++                break;
++            }
++        }
++
++        return false;
++    }
++
++    bool handle_motion_event(MirMotionEvent const& event)
++    {
++        if (event.action == mir_motion_action_down ||
++            event.action == mir_motion_action_pointer_down)
++        {
++            if (auto const wm = window_manager.lock())
++            {
++                wm->click(average_pointer(event.pointer_count, event.pointer_coordinates));
++                return false;
++            }
++        }
++        else if (event.action == mir_motion_action_move &&
++                 event.modifiers & mir_key_modifier_alt)
++        {
++            if (auto const wm = window_manager.lock())
++            {
++                switch (event.button_state)
++                {
++                case mir_motion_button_primary:
++                    wm->drag(average_pointer(event.pointer_count, event.pointer_coordinates));
++                    return true;
++
++                case mir_motion_button_tertiary:
++                    wm->resize(average_pointer(event.pointer_count, event.pointer_coordinates));
++                    return true;
++
++                default:
++                    ;// ignore
++                }
++            }
++        }
++
++        return false;
++    }
++
++    static Point average_pointer(size_t pointer_count, MirMotionPointer const* pointer_coordinates)
++    {
++        long total_x = 0;
++        long total_y = 0;
++
++        for (auto p = pointer_coordinates; p != pointer_coordinates + pointer_count; ++p)
++        {
++            total_x += p->x;
++            total_y += p->y;
++        }
++
++        return Point{total_x/pointer_count, total_y/pointer_count};
++    }
++
++    std::weak_ptr<me::WindowManager> const window_manager;
++};
++
++auto me::WindowManagmentFactory::window_manager() -> std::shared_ptr<me::WindowManager>
++{
++    auto tmp = wm.lock();
++
++    if (!tmp)
++    {
++        auto const options = server.get_options();
++        auto const selection = options->get<std::string>(wm_option);
++
++        if (selection == wm_tiling)
++        {
++            auto focus_controller_factory = [this] { return server.the_focus_controller(); };
++            tmp = std::make_shared<TilingWindowManager>(focus_controller_factory);
++        }
++        else if (selection == wm_fullscreen)
++            tmp = std::make_shared<FullscreenWindowManager>(server.the_shell_display_layout());
++        else
++            throw mir::AbnormalExit("Unknown window manager: " + selection);
++
++        et = std::make_shared<EventTracker>(tmp);
++        server.the_composite_event_filter()->prepend(et);
++        wm = tmp;
++    }
++
++    return tmp;
++}
 === added file 'examples/server_example_window_management.h'
 --- examples/server_example_window_management.h	1970-01-01 00:00:00 +0000
 +++ examples/server_example_window_management.h	2015-01-14 12:09:57 +0000
@@ -0,0 +1,95 @@
++/*
++ * 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 <alan@octopull.co.uk>
++ */
++
++#ifndef MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
++#define MIR_EXAMPLES_WINDOW_MANAGEMENT_H_
++
++#include "mir/geometry/rectangles.h"
++#include "mir/scene/session.h"
++#include "mir/scene/surface.h"
++#include "mir/scene/placement_strategy.h"
++#include "mir/scene/surface_configurator.h"
++#include "mir/scene/surface_creation_parameters.h"
++
++#include <memory>
++
++///\example server_example_window_management.h
++/// Demonstrate simple window management strategies
++
++namespace mir
++{
++class Server;
++
++namespace examples
++{
++class WindowManager :
++    public virtual scene::PlacementStrategy,
++    public virtual scene::SurfaceConfigurator
++{
++public:
++
++    virtual void add_surface(
++        std::shared_ptr<scene::Surface> const& surface,
++        scene::Session* session) = 0;
++
++    virtual void remove_surface(
++        std::weak_ptr<scene::Surface> const& surface,
++        scene::Session* session) = 0;
++
++    virtual void add_session(std::shared_ptr<scene::Session> const& session) = 0;
++
++    virtual void remove_session(std::shared_ptr<scene::Session> const& session) = 0;
++
++    virtual void add_display(geometry::Rectangle const& area) = 0;
++
++    virtual void remove_display(geometry::Rectangle const& area) = 0;
++
++    virtual void click(geometry::Point cursor) = 0;
++
++    virtual void drag(geometry::Point cursor) = 0;
++
++    virtual void resize(geometry::Point cursor) = 0;
++
++    virtual void toggle_maximized() = 0;
++
++    virtual void toggle_max_horizontal() = 0;
++
++    virtual void toggle_max_vertical() = 0;
++};
++
++class EventTracker;
++
++class WindowManagmentFactory
++{
++public:
++    explicit WindowManagmentFactory(Server& server) : server{server} {}
++
++    auto window_manager() -> std::shared_ptr<WindowManager>;
++
++private:
++    Server& server;
++    std::weak_ptr<WindowManager> wm;
++    std::shared_ptr<EventTracker> et;
++};
++
++extern char const* const wm_option;
++extern char const* const wm_description;
++}
++}
++
++#endif
 === modified file 'examples/server_example_window_manager.cpp'
 --- examples/server_example_window_manager.cpp	2015-01-05 14:50:58 +0000
 +++ examples/server_example_window_manager.cpp	2015-01-14 12:09:57 +0000
@@ -17,317 +17,60 @@
   */
  #include "server_example_window_manager.h"
--#include "server_example_fullscreen_placement_strategy.h"
++#include "server_example_window_management.h"
--#include "mir/abnormal_exit.h"
  #include "mir/server.h"
  #include "mir/compositor/display_buffer_compositor_factory.h"
  #include "mir/compositor/display_buffer_compositor.h"
--#include "mir/geometry/rectangles.h"
--#include "mir/geometry/displacement.h"
  #include "mir/graphics/display_buffer.h"
  #include "mir/options/option.h"
--#include "mir/scene/observer.h"
--#include "mir/scene/session.h"
--#include "mir/scene/surface.h"
--#include "mir/scene/placement_strategy.h"
--#include "mir/scene/surface_creation_parameters.h"
--#include "mir/shell/session_coordinator_wrapper.h"
--#include "mir/shell/surface_coordinator_wrapper.h"
--
--#include <algorithm>
--#include <map>
--#include <mutex>
++#include "mir/scene/session_listener.h"
  namespace mc = mir::compositor;
  namespace me = mir::examples;
--namespace mf = mir::frontend;
  namespace mg = mir::graphics;
  namespace ms = mir::scene;
--namespace msh = mir::shell;
  using namespace mir::geometry;
  ///\example server_example_window_manager.cpp
--/// Demonstrate a simple window management strategy
++/// Demonstrate introducing a window management strategy
  namespace
+ {
--class WindowManager : public virtual ms::PlacementStrategy
--{
--public:
--
--    virtual void add_surface(
--        std::shared_ptr<ms::Surface> const& surface,
--        ms::Session* session) = 0;
--
--    virtual void remove_surface(std::weak_ptr<ms::Surface> const& surface) = 0;
--
--    virtual void add_session(std::shared_ptr<mf::Session> const& session) = 0;
--
--    virtual void remove_session(std::shared_ptr<mf::Session> const& session) = 0;
--
--    virtual void add_display(Rectangle const& area) = 0;
--
--    virtual void remove_display(Rectangle const& area) = 0;
--};
--
--class FullscreenWindowManager : public WindowManager, me::FullscreenPlacementStrategy
--{
--public:
--    using me::FullscreenPlacementStrategy::FullscreenPlacementStrategy;
--
--private:
--    void add_surface(std::shared_ptr<ms::Surface> const&, ms::Session*) override {}
--
--    void remove_surface(std::weak_ptr<ms::Surface> const&) override {}
--
--    void add_session(std::shared_ptr<mf::Session> const&) override {}
--
--    void remove_session(std::shared_ptr<mf::Session> const&) override {}
--
--    void add_display(Rectangle const&) override {}
--
--    void remove_display(Rectangle const&) override {}
--};
--
--class TilingWindowManager : public WindowManager
--{
--    auto place(ms::Session const& session, ms::SurfaceCreationParameters const& request_parameters)
--    -> ms::SurfaceCreationParameters override
--    {
--        auto parameters = request_parameters;
--
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        auto const ptile = tiles.find(&session);
--        if (ptile != end(tiles))
--        {
--            Rectangle const& tile = ptile->second;
--            parameters.top_left = parameters.top_left + (tile.top_left - Point{0, 0});
--
--            clip_to_tile(parameters, tile);
--        }
--
--        return parameters;
--    }
--
--    void add_surface(
--        std::shared_ptr<ms::Surface> const& surface,
--        ms::Session* session)
--    {
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        surfaces.emplace(session, surface);
--    }
--
--    void remove_surface(std::weak_ptr<ms::Surface> const& /*surface*/)
--    {
--        // This looks odd but we want to block in case we're using the surface
--        std::lock_guard<decltype(mutex)> lock(mutex);
--    }
--
--    void add_session(std::shared_ptr<mf::Session> const& session)
--    {
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        tiles[session.get()] = Rectangle{};
--        update_tiles();
--    }
--
--    void remove_session(std::shared_ptr<mf::Session> const& session)
--    {
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        tiles.erase(session.get());
--        surfaces.erase(session.get());
--        update_tiles();
--    }
--
--    void add_display(Rectangle const& area)
--    {
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        displays.push_back(area);
--        update_tiles();
--    }
--
--    void remove_display(Rectangle const& area)
--    {
--        std::lock_guard<decltype(mutex)> lock(mutex);
--        auto const i = std::find(begin(displays), end(displays), area);
--        if (i != end(displays)) displays.erase(i);
--        update_tiles();
--    }
--
--private:
--    void update_tiles()
--    {
--        if (tiles.size() < 1 || displays.size() < 1) return;
--
--        auto const sessions = tiles.size();
--        Rectangles view;
--
--        for (auto const& display : displays)
--            view.add(display);
--
--        auto const bounding_rect = view.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& tile : tiles)
--        {
--            auto const x = (total_width*index)/sessions;
--            ++index;
--            auto const dx = (total_width*index)/sessions - x;
--
--            auto const old_tile = tile.second;
--            Rectangle const new_tile{{x, 0}, {dx, total_height}};
--
--            update_surfaces(tile.first, old_tile, new_tile);
--
--            tile.second = new_tile;
--        }
--    }
--
--    void update_surfaces(mf::Session const* session, Rectangle const& old_tile, Rectangle const& new_tile)
--    {
--        auto displacement = new_tile.top_left - old_tile.top_left;
--        auto const moved = surfaces.equal_range(session);
--
--        for (auto p = moved.first; p != moved.second; ++p)
--        {
--            if (auto const surface = p->second.lock())
--            {
--                auto const old_pos = surface->top_left();
--                surface->move_to(old_pos + displacement);
--
--                fit_to_new_tile(*surface, old_tile, new_tile);
--            }
--        }
--    }
--
--    static void 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};
--    }
--
--    static void 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});
--    }
--
--    std::mutex mutex;
--    std::vector<Rectangle> displays;
--    std::map<mf::Session const*, Rectangle> tiles;
--    std::multimap<mf::Session const*, std::weak_ptr<ms::Surface>> surfaces;
--};
--
--auto const option = "window-manager";
--auto const description = "window management strategy [{tiling|fullscreen}]";
--auto const tiling = "tiling";
--auto const fullscreen = "fullscreen";
--
--class WindowManagmentFactory
--{
--public:
--    explicit WindowManagmentFactory(mir::Server& server) : server{server} {}
--
--    auto window_manager() -> std::shared_ptr<WindowManager>
--    {
--        auto tmp = wm.lock();
--
--        if (!tmp)
--        {
--            auto const options = server.get_options();
--            auto const selection = options->get<std::string>(option);
--
--            if (selection == tiling)
--                tmp = std::make_shared<TilingWindowManager>();
--            else if (selection == fullscreen)
--                tmp = std::make_shared<FullscreenWindowManager>(server.the_shell_display_layout());
--            else
--                throw mir::AbnormalExit("Unknown window manager: " + selection);
--
--            wm = tmp;
--        }
--
--        return tmp;
--    }
--
--private:
--    mir::Server& server;
--    std::weak_ptr<WindowManager> wm;
--};
--
--class SessionTracker : public msh::SessionCoordinatorWrapper
--{
--public:
--    SessionTracker(
--        std::shared_ptr<ms::SessionCoordinator> const& wrapped,
--        std::shared_ptr<WindowManager> const& window_manager) :
--        msh::SessionCoordinatorWrapper(wrapped),
++class SceneTracker : public ms::SessionListener
++{
++public:
++    SceneTracker(std::shared_ptr<me::WindowManager> const& window_manager) :
          window_manager(window_manager)
+     {
+     }
  private:
--    auto open_session(pid_t client_pid, std::string const& name, std::shared_ptr<mf::EventSink> const& sink)
--    -> std::shared_ptr<mf::Session> override
++
++    void starting(std::shared_ptr<ms::Session> const& session) override
+     {
--        auto const new_session = msh::SessionCoordinatorWrapper::open_session(client_pid, name, sink);
--        window_manager->add_session(new_session);
--        return new_session;
++        window_manager->add_session(session);
+     }
--    void close_session(std::shared_ptr<mf::Session> const& session) override
++    void stopping(std::shared_ptr<ms::Session> const& session) override
+     {
          window_manager->remove_session(session);
--        msh::SessionCoordinatorWrapper::close_session(session);
--    }
--
--    std::shared_ptr<WindowManager> const window_manager;
--};
--
--class SurfaceTracker : public msh::SurfaceCoordinatorWrapper
--{
--public:
--    SurfaceTracker(
--        std::shared_ptr<ms::SurfaceCoordinator> const& wrapped,
--        std::shared_ptr<WindowManager> const& window_manager) :
--        msh::SurfaceCoordinatorWrapper(wrapped),
--        window_manager(window_manager)
--    {
--    }
--
--private:
--    auto add_surface(ms::SurfaceCreationParameters const& params, ms::Session* session)
--    -> std::shared_ptr<ms::Surface> override
--    {
--        auto const new_surface = msh::SurfaceCoordinatorWrapper::add_surface(params, session);
--        window_manager->add_surface(new_surface, session);
--        return new_surface;
--    }
--
--    void remove_surface(std::weak_ptr<ms::Surface> const& surface)
--    {
--        window_manager->remove_surface(surface);
--        msh::SurfaceCoordinatorWrapper::remove_surface(surface);
--    }
--
--    std::shared_ptr<WindowManager> const window_manager;
++    }
++
++    void focused(std::shared_ptr<ms::Session> const& /*session*/) override {}
++    void unfocused() override {}
++
++    void surface_created(ms::Session& session, std::shared_ptr<ms::Surface> const& surface) override
++    {
++        window_manager->add_surface(surface, &session);
++    }
++
++    void destroying_surface(ms::Session& session, std::shared_ptr<ms::Surface> const& surface) override
++    {
++        window_manager->remove_surface(surface, &session);
++    }
++
++    std::shared_ptr<me::WindowManager> const window_manager;
  };
  class DisplayTracker : public mc::DisplayBufferCompositor
@@ -336,7 +79,7 @@
      DisplayTracker(
          std::unique_ptr<mc::DisplayBufferCompositor>&& wrapped,
          Rectangle const& area,
--        std::shared_ptr<WindowManager> const& window_manager) :
++        std::shared_ptr<me::WindowManager> const& window_manager) :
          wrapped{std::move(wrapped)},
          area{area},
          window_manager(window_manager)
@@ -358,7 +101,7 @@
      std::unique_ptr<mc::DisplayBufferCompositor> const wrapped;
      Rectangle const area;
--    std::shared_ptr<WindowManager> const window_manager;
++    std::shared_ptr<me::WindowManager> const window_manager;
  };
  class DisplayTrackerFactory : public mc::DisplayBufferCompositorFactory
@@ -366,7 +109,7 @@
  public:
      DisplayTrackerFactory(
          std::shared_ptr<mc::DisplayBufferCompositorFactory> const& wrapped,
--        std::shared_ptr<WindowManager> const& window_manager) :
++        std::shared_ptr<me::WindowManager> const& window_manager) :
          wrapped{wrapped},
          window_manager(window_manager)
+     {
@@ -381,49 +124,47 @@
+     }
      std::shared_ptr<mc::DisplayBufferCompositorFactory> const wrapped;
--    std::shared_ptr<WindowManager> const window_manager;
++    std::shared_ptr<me::WindowManager> const window_manager;
  };
+ }
  void me::add_window_manager_option_to(Server& server)
+ {
--    server.add_configuration_option(option, description, mir::OptionType::string);
++    server.add_configuration_option(me::wm_option, me::wm_description, mir::OptionType::string);
--    auto const factory = std::make_shared<WindowManagmentFactory>(server);
++    auto const factory = std::make_shared<me::WindowManagmentFactory>(server);
      server.override_the_placement_strategy([factory, &server]()
          -> std::shared_ptr<ms::PlacementStrategy>
+         {
              auto const options = server.get_options();
--            if (!options->is_set(option))
++            if (!options->is_set(me::wm_option))
                  return std::shared_ptr<ms::PlacementStrategy>{};
              return factory->window_manager();
          });
--    server.wrap_session_coordinator([factory, &server]
--        (std::shared_ptr<ms::SessionCoordinator> const& wrapped)
--        -> std::shared_ptr<ms::SessionCoordinator>
++    server.override_the_session_listener([factory, &server]()
++        -> std::shared_ptr<ms::SessionListener>
+         {
              auto const options = server.get_options();
--            if (!options->is_set(option))
--                return wrapped;
++            if (!options->is_set(me::wm_option))
++                return std::shared_ptr<ms::SessionListener>{};
--            return std::make_shared<SessionTracker>(wrapped, factory->window_manager());
++            return std::make_shared<SceneTracker>(factory->window_manager());
          });
--    server.wrap_surface_coordinator([factory, &server]
--        (std::shared_ptr<ms::SurfaceCoordinator> const& wrapped)
--        -> std::shared_ptr<ms::SurfaceCoordinator>
++    server.override_the_surface_configurator([factory, &server]()
++        -> std::shared_ptr<ms::SurfaceConfigurator>
+         {
              auto const options = server.get_options();
--            if (!options->is_set(option))
--                return wrapped;
++            if (!options->is_set(me::wm_option))
++                return std::shared_ptr<ms::SurfaceConfigurator>{};
--            return std::make_shared<SurfaceTracker>(wrapped, factory->window_manager());
++            return factory->window_manager();
          });
      server.wrap_display_buffer_compositor_factory([factory, &server]
@@ -432,7 +173,7 @@
+        {
             auto const options = server.get_options();
--           if (!options->is_set(option))
++           if (!options->is_set(me::wm_option))
                 return wrapped;
             return std::make_shared<DisplayTrackerFactory>(wrapped, factory->window_manager());