Merge lp:~alan-griffiths/miral/move-WM-logic-into-BasicWindowManager into lp:miral

[Alan Griffiths]

Put most of the default window management logic into BasicWindowManager and provide a default CanonicalWindowManagerPolicy in libmiral

Put most of the default window management logic into BasicWindowManager and provide a default CanonicalWindowManagerPolicy in libmiral

[lp:~alan-griffiths/miral/move-WM-logic-into-BasicWindowManager]

200. By Alan Griffiths on 2016-06-03

merge :parent

=== renamed file 'miral-shell/canonical_window_manager.h' => 'include/miral/canonical_window_manager.h'
--- miral-shell/canonical_window_manager.h	2016-06-03 15:11:50 +0000
+++ include/miral/canonical_window_manager.h	2016-06-03 15:27:17 +0000
@@ -16,10 +16,8 @@
  * Authored By: Alan Griffiths <[e-mail]>
  */
 
-#ifndef MIRAL_SHELL_CANONICAL_WINDOW_MANAGER_H_
-#define MIRAL_SHELL_CANONICAL_WINDOW_MANAGER_H_
-
-#include "spinner/splash.h"
+#ifndef MIRAL_CANONICAL_WINDOW_MANAGER_H_
+#define MIRAL_CANONICAL_WINDOW_MANAGER_H_
 
 #include <miral/window.h>
 #include <miral/window_management_policy.h>
@@ -29,6 +27,8 @@
 #include <atomic>
 #include <set>
 
+namespace miral
+{
 using namespace mir::geometry;
 
 // Based on "Mir and Unity: Surfaces, input, and displays (v0.3)"
@@ -41,32 +41,36 @@
 //  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 CanonicalWindowManagerPolicy  : public miral::WindowManagementPolicy
+class CanonicalWindowManagerPolicy  : public WindowManagementPolicy
 {
 public:
 
-    explicit CanonicalWindowManagerPolicy(miral::WindowManagerTools* const tools, SpinnerSplash const& spinner);
+    explicit CanonicalWindowManagerPolicy(WindowManagerTools* const tools);
 
     auto place_new_surface(
-        miral::ApplicationInfo const& app_info,
-        miral::WindowSpecification const& request_parameters)
-        -> miral::WindowSpecification override;
-
-    void handle_app_info_updated(Rectangles const& displays) override;
-    void handle_displays_updated(Rectangles const& displays) override;
-    void advise_new_window(miral::WindowInfo& window_info) override;
-    void handle_window_ready(miral::WindowInfo& window_info) override;
-    void handle_modify_window(miral::WindowInfo& window_info, miral::WindowSpecification const& modifications) override;
-    void advise_delete_window(miral::WindowInfo const& window_info) override;
+        ApplicationInfo const& app_info,
+        WindowSpecification const& request_parameters)
+        -> WindowSpecification override;
+
+    void handle_window_ready(WindowInfo& window_info) override;
+    void handle_modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override;
+    void handle_raise_window(WindowInfo& window_info) 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_window(miral::WindowInfo& window_info) override;
-
-    void advise_focus_lost(miral::WindowInfo const& info) override;
-    void advise_focus_gained(miral::WindowInfo const& info) override;
-
-private:
+
+    void advise_new_window(WindowInfo& window_info) override;
+    void advise_focus_lost(WindowInfo const& info) override;
+    void advise_focus_gained(WindowInfo const& info) override;
+    void advise_state_change(WindowInfo const& window_info, MirSurfaceState state) override;
+    void advise_resize(WindowInfo const& window_info, Size const& new_size) override;
+    void advise_delete_window(WindowInfo const& window_info) override;
+
+    void handle_app_info_updated(Rectangles const& displays) override;
+    void handle_displays_updated(Rectangles const& displays) override;
+
+protected:
     static const int modifier_mask =
         mir_input_event_modifier_alt |
         mir_input_event_modifier_shift |
@@ -74,30 +78,28 @@
         mir_input_event_modifier_ctrl |
         mir_input_event_modifier_meta;
 
+private:
     void drag(Point cursor);
     void click(Point cursor);
     bool resize(Point cursor);
     void toggle(MirSurfaceState state);
 
 
-    bool resize(miral::Window const& window, Point cursor, Point old_cursor);
-
-    void apply_resize(miral::WindowInfo& window_info, Point new_pos, Size new_size) const;
-    void apply_set_state(miral::WindowInfo& window_info, MirSurfaceState value);
-    void generate_decorations_for(miral::WindowInfo& window_info);
-
-    miral::WindowManagerTools* const tools;
-    SpinnerSplash const spinner;
+    bool resize(Window const& window, Point cursor, Point old_cursor);
+
+    WindowManagerTools* const tools;
 
     Rectangle display_area;
     Point old_cursor{};
-    using FullscreenSurfaces = std::set<miral::Window>;
+    using FullscreenSurfaces = std::set<Window>;
 
     FullscreenSurfaces fullscreen_surfaces;
 
     bool resizing = false;
     bool left_resize = false;
     bool top_resize  = false;
+
 };
+}
 
-#endif /* MIRAL_SHELL_CANONICAL_WINDOW_MANAGER_H_ */
+#endif /* MIRAL_CANONICAL_WINDOW_MANAGER_H_ */

=== modified file 'include/miral/window.h'
--- include/miral/window.h	2016-04-22 08:54:29 +0000
+++ include/miral/window.h	2016-06-03 15:27:17 +0000
@@ -53,7 +53,6 @@
     auto input_area_contains(mir::geometry::Point const& point) const -> bool;
     auto application()  const -> Application;
 
-
     void configure_streams(std::vector<StreamSpecification> const& config);
 
     // Indicates that the Window isn't null
@@ -63,13 +62,8 @@
     void resize(mir::geometry::Size const& size);
     void show();
     void hide();
-    void rename(std::string const& name);
     void move_to(mir::geometry::Point top_left);
-    void set_input_region(std::vector<mir::geometry::Rectangle> const& input_rectangles);
     void set_state(MirSurfaceState state);
-    void set_type(MirSurfaceType type);
-
-    void reset();
 
     void request_client_surface_close() const;
 

=== modified file 'include/miral/window_management_policy.h'
--- include/miral/window_management_policy.h	2016-06-03 09:06:20 +0000
+++ include/miral/window_management_policy.h	2016-06-03 15:27:17 +0000
@@ -29,6 +29,8 @@
 struct ApplicationInfo;
 struct WindowInfo;
 
+using namespace mir::geometry;
+
 /// The interface through which the policy invoked.
 class WindowManagementPolicy
 {
@@ -61,14 +63,16 @@
     virtual void advise_new_window(WindowInfo& window_info) = 0;
     virtual void advise_focus_lost(WindowInfo const& info) = 0;
     virtual void advise_focus_gained(WindowInfo const& info) = 0;
+    virtual void advise_state_change(WindowInfo const& window_info, MirSurfaceState state) = 0;
+    virtual void advise_resize(WindowInfo const& window_info, Size const& new_size) = 0;
     virtual void advise_delete_window(WindowInfo const& window_info) = 0;
 /** @} */
 
 /** @name Changes to the applications or displays
  * \todo these are very course grained and should probably be replaced
  *  @{ */
-    virtual void handle_app_info_updated(mir::geometry::Rectangles const& displays) = 0;
-    virtual void handle_displays_updated(mir::geometry::Rectangles const& displays) = 0;
+    virtual void handle_app_info_updated(Rectangles const& displays) = 0;
+    virtual void handle_displays_updated(Rectangles const& displays) = 0;
 /** @} */
 
     virtual ~WindowManagementPolicy() = default;

=== modified file 'include/miral/window_manager_tools.h'
--- include/miral/window_manager_tools.h	2016-06-02 16:53:17 +0000
+++ include/miral/window_manager_tools.h	2016-06-03 15:27:17 +0000
@@ -20,6 +20,7 @@
 #define MIRAL_WINDOW_MANAGER_TOOLS_H
 
 #include "miral/application.h"
+#include "window_info.h"
 
 #include <mir/geometry/displacement.h>
 
@@ -67,7 +68,10 @@
     virtual auto active_display() -> mir::geometry::Rectangle const = 0;
     virtual void destroy(Window& window) = 0;
     virtual void raise_tree(Window const& root) = 0;
-    virtual void move_tree(WindowInfo& root, mir::geometry::Displacement movement) = 0;
+    virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0;
+    virtual void place_and_size(WindowInfo& window_info, Point const& new_pos, Size const& new_size) = 0;
+    virtual void set_state(WindowInfo& window_info, MirSurfaceState value) = 0;
+
     virtual void size_to_output(mir::geometry::Rectangle& rect) = 0;
     virtual bool place_in_output(int id, mir::geometry::Rectangle& rect) = 0;
 /** @} */

=== modified file 'miral-kiosk/kiosk_window_manager.cpp'
--- miral-kiosk/kiosk_window_manager.cpp	2016-06-03 09:06:20 +0000
+++ miral-kiosk/kiosk_window_manager.cpp	2016-06-03 15:27:17 +0000
@@ -123,8 +123,26 @@
     miral::WindowInfo& window_info,
     miral::WindowSpecification const& modifications)
 {
-    if (modifications.name().is_set())
-        window_info.window().rename(modifications.name().value());
+    auto mods = modifications;
+
+    // filter out changes we don't want the client making
+    mods.top_left().consume();
+    mods.size().consume();
+    mods.output_id().consume();
+    mods.state().consume();
+    mods.preferred_orientation().consume();
+    mods.edge_attachment().consume();
+    mods.min_width().consume();
+    mods.min_height().consume();
+    mods.max_width().consume();
+    mods.max_height().consume();
+    mods.width_inc().consume();
+    mods.height_inc().consume();
+    mods.min_aspect().consume();
+    mods.max_aspect().consume();
+    mods.parent().consume();
+
+    tools->modify_window(window_info, mods);
 }
 
 void KioskWindowManagerPolicy::advise_delete_window(WindowInfo const& /*window_info*/)
@@ -177,6 +195,8 @@
 
     Point const cursor{total_x/count, total_y/count};
 
+    tools->select_active_window(tools->window_at(cursor));
+
     return false;
 }
 
@@ -196,8 +216,10 @@
     return false;
 }
 
-void KioskWindowManagerPolicy::raise_splash_session() const
+void KioskWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
+    tools->raise_tree(info.window());
+
     if (auto session = splash.session().lock())
     {
         auto const& app_info = tools->info_for(session);
@@ -207,11 +229,14 @@
     }
 }
 
-void KioskWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
-{
-    tools->raise_tree(info.window());
-}
-
 void KioskWindowManagerPolicy::advise_focus_lost(WindowInfo const& /*info*/)
 {
 }
+
+void KioskWindowManagerPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirSurfaceState /*state*/)
+{
+}
+
+void KioskWindowManagerPolicy::advise_resize(WindowInfo const& /*window_info*/, Size const& /*new_size*/)
+{
+}

=== modified file 'miral-kiosk/kiosk_window_manager.h'
--- miral-kiosk/kiosk_window_manager.h	2016-06-03 09:06:20 +0000
+++ miral-kiosk/kiosk_window_manager.h	2016-06-03 15:27:17 +0000
@@ -58,6 +58,8 @@
     void advise_focus_lost(miral::WindowInfo const& info) override;
 
     void advise_focus_gained(miral::WindowInfo const& info) override;
+    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state) override;
+    void advise_resize(miral::WindowInfo const& window_info, Size const& new_size) override;
 
 private:
     static const int modifier_mask =
@@ -67,8 +69,6 @@
         mir_input_event_modifier_ctrl |
         mir_input_event_modifier_meta;
 
-    void raise_splash_session() const;
-
     miral::WindowManagerTools* const tools;
 
     SwSplash const splash;

=== modified file 'miral-shell/CMakeLists.txt'
--- miral-shell/CMakeLists.txt	2016-04-16 23:13:59 +0000
+++ miral-shell/CMakeLists.txt	2016-06-03 15:27:17 +0000
@@ -12,9 +12,8 @@
 
 add_executable(miral-shell
     shell_main.cpp
-    canonical_window_manager.cpp canonical_window_manager.h
     tiling_window_manager.cpp    tiling_window_manager.h
-)
+    titlebar_window_manager.cpp titlebar_window_manager.h)
 
 target_link_libraries(miral-shell
     miral-spinner

=== modified file 'miral-shell/shell_main.cpp'
--- miral-shell/shell_main.cpp	2016-04-15 16:43:27 +0000
+++ miral-shell/shell_main.cpp	2016-06-03 15:27:17 +0000
@@ -17,14 +17,15 @@
  */
 
 #include "tiling_window_manager.h"
-#include "canonical_window_manager.h"
+#include "titlebar_window_manager.h"
 #include "spinner/splash.h"
 
-#include "miral/display_configuration_option.h"
-#include "miral/runner.h"
-#include "miral/window_management_options.h"
-#include "miral/quit_on_ctrl_alt_bksp.h"
-#include "miral/startup_internal_client.h"
+#include <miral/canonical_window_manager.h>
+#include <miral/display_configuration_option.h>
+#include <miral/runner.h>
+#include <miral/window_management_options.h>
+#include <miral/quit_on_ctrl_alt_bksp.h>
+#include <miral/startup_internal_client.h>
 
 int main(int argc, char const* argv[])
 {
@@ -36,7 +37,8 @@
         {
             WindowManagerOptions
                 {
-                    add_window_manager_policy<CanonicalWindowManagerPolicy>("canonical", spinner),
+                    add_window_manager_policy<TitlebarWindowManagerPolicy>("titlebar", spinner),
+                    add_window_manager_policy<CanonicalWindowManagerPolicy>("canonical"),
                     add_window_manager_policy<TilingWindowManagerPolicy>("tiling"),
                 },
             display_configuration_options,

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2016-06-03 09:06:20 +0000
+++ miral-shell/tiling_window_manager.cpp	2016-06-03 15:27:17 +0000
@@ -161,14 +161,29 @@
     miral::WindowInfo& window_info,
     miral::WindowSpecification const& modifications)
 {
-    if (modifications.name().is_set())
-        window_info.window().rename(modifications.name().value());
-
-    if (modifications.state().is_set())
+    auto mods = modifications;
+
+    // filter out changes we don't want the client making
+    mods.top_left().consume();
+    mods.size().consume();
+    mods.output_id().consume();
+    mods.edge_attachment().consume();
+    mods.min_width().consume();
+    mods.min_height().consume();
+    mods.max_width().consume();
+    mods.max_height().consume();
+    mods.width_inc().consume();
+    mods.height_inc().consume();
+    mods.min_aspect().consume();
+    mods.max_aspect().consume();
+
+    if (mods.state().is_set())
     {
-        auto state = transform_set_state(window_info, modifications.state().value());
+        auto state = transform_set_state(window_info, mods.state().consume());
         window_info.window().set_state(state);
     }
+
+    tools->modify_window(window_info, mods);
 }
 
 void TilingWindowManagerPolicy::advise_delete_window(WindowInfo const& /*window_info*/)
@@ -462,15 +477,10 @@
 
 void TilingWindowManagerPolicy::update_surfaces(ApplicationInfo& info, Rectangle const& old_tile, Rectangle const& new_tile)
 {
-    auto displacement = new_tile.top_left - old_tile.top_left;
-
     for (auto& window : info.windows())
     {
         if (window)
         {
-            auto const old_pos = window.top_left();
-            window.move_to(old_pos + displacement);
-
             fit_to_new_tile(window, old_tile, new_tile);
         }
     }
@@ -488,17 +498,18 @@
 
 void TilingWindowManagerPolicy::fit_to_new_tile(miral::Window& window, Rectangle const& old_tile, Rectangle const& new_tile)
 {
-    auto const displacement = window.top_left() - new_tile.top_left;
+    auto const new_pos = window.top_left() + (new_tile.top_left - old_tile.top_left);
+    auto const offset = new_pos - new_tile.top_left;
 
     // For now just scale if was filling width/height of tile
     auto const old_size = window.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());
+    auto width = std::min(new_tile.size.width.as_int()-offset.dx.as_int(), scaled_width.as_int());
+    auto height = std::min(new_tile.size.height.as_int()-offset.dy.as_int(), scaled_height.as_int());
 
-    window.resize({width, height});
+    tools->place_and_size(tools->info_for(window), new_pos, {width, height});
 }
 
 void TilingWindowManagerPolicy::drag(WindowInfo& window_info, Point to, Point from, Rectangle bounds)
@@ -580,3 +591,12 @@
 void TilingWindowManagerPolicy::advise_focus_lost(WindowInfo const& /*info*/)
 {
 }
+
+void TilingWindowManagerPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirSurfaceState /*state*/)
+{
+}
+
+void TilingWindowManagerPolicy::advise_resize(WindowInfo const& /*window_info*/, Size const& /*new_size*/)
+{
+}
+

=== modified file 'miral-shell/tiling_window_manager.h'
--- miral-shell/tiling_window_manager.h	2016-06-03 15:11:50 +0000
+++ miral-shell/tiling_window_manager.h	2016-06-03 15:27:17 +0000
@@ -59,6 +59,8 @@
 
     void advise_focus_lost(miral::WindowInfo const& info) override;
     void advise_focus_gained(miral::WindowInfo const& info) override;
+    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state) override;
+    void advise_resize(miral::WindowInfo const& window_info, Size const& new_size) override;
 
 private:
     static const int modifier_mask =
@@ -81,7 +83,7 @@
     auto transform_set_state(miral::WindowInfo& window_info, MirSurfaceState value) -> MirSurfaceState;
 
     static void clip_to_tile(miral::WindowSpecification& parameters, Rectangle const& tile);
-    static void fit_to_new_tile(miral::Window& window, Rectangle const& old_tile, Rectangle const& new_tile);
+    void fit_to_new_tile(miral::Window& window, Rectangle const& old_tile, Rectangle const& new_tile);
     static void resize(miral::Window window, Point cursor, Point old_cursor, Rectangle bounds);
     static void constrained_move(miral::Window window, Displacement& movement, Rectangle const& bounds);
 

=== added file 'miral-shell/titlebar_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	1970-01-01 00:00:00 +0000
+++ miral-shell/titlebar_window_manager.cpp	2016-06-03 15:27:17 +0000
@@ -0,0 +1,208 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "titlebar_window_manager.h"
+#include "titlebar/canonical_window_management_policy_data.h"
+
+#include <miral/application_info.h>
+#include <miral/window_info.h>
+#include <miral/window_manager_tools.h>
+
+using namespace miral;
+
+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)
+    };
+}
+}
+
+TitlebarWindowManagerPolicy::TitlebarWindowManagerPolicy(WindowManagerTools* const tools, SpinnerSplash const& spinner) :
+    CanonicalWindowManagerPolicy(tools),
+    tools(tools),
+    spinner{spinner}
+{
+}
+
+bool TitlebarWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
+{
+    auto consumes_event = CanonicalWindowManagerPolicy::handle_pointer_event(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)};
+
+
+    if (!consumes_event && action == mir_pointer_action_motion && !modifiers)
+    {
+        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
+        {
+            // TODO this is a rather roundabout way to detect a titlebar
+            if (auto const possible_titlebar = tools->window_at(old_cursor))
+            {
+                if (auto const parent = tools->info_for(possible_titlebar).parent())
+                {
+                    if (auto const& parent_userdata =
+                        std::static_pointer_cast<CanonicalWindowManagementPolicyData>(tools->info_for(parent).userdata()))
+                    {
+                        if (possible_titlebar == parent_userdata->window)
+                        {
+                            if (auto const target = tools->window_at(old_cursor))
+                            {
+                                tools->select_active_window(target);
+                                tools->drag_active_window(cursor - old_cursor);
+                            }
+                            consumes_event = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    old_cursor = cursor;
+    return consumes_event;
+}
+
+
+void TitlebarWindowManagerPolicy::advise_new_window(WindowInfo& window_info)
+{
+    CanonicalWindowManagerPolicy::advise_new_window(window_info);
+
+    if (!window_info.needs_titlebar(window_info.type()))
+        return;
+
+    Window const& window = window_info.window();
+
+    auto format = mir_pixel_format_xrgb_8888;
+    WindowSpecification params;
+    params.size() = titlebar_size_for_window(window.size());
+    params.name() = "decoration";
+    params.pixel_format() = format;
+    params.buffer_usage() = WindowSpecification::BufferUsage::software;
+    params.top_left() = titlebar_position_for_window(window.top_left());
+    params.type() = mir_surface_type_gloss;
+
+    auto& titlebar_info = tools->build_window(window.application(), params);
+    titlebar_info.window().set_alpha(0.9);
+    titlebar_info.parent(window);
+
+    auto data = std::make_shared<CanonicalWindowManagementPolicyData>(titlebar_info.window());
+    window_info.userdata(data);
+    window_info.add_child(titlebar_info.window());
+}
+
+void TitlebarWindowManagerPolicy::advise_focus_lost(WindowInfo const& info)
+{
+    CanonicalWindowManagerPolicy::advise_focus_lost(info);
+
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
+    {
+        titlebar->paint_titlebar(0x3F);
+    }
+}
+
+void TitlebarWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
+{
+    CanonicalWindowManagerPolicy::advise_focus_gained(info);
+
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
+    {
+        titlebar->paint_titlebar(0xFF);
+    }
+
+    // Frig to force the spinner to the top
+    if (auto const spinner_session = spinner.session())
+    {
+        auto const& spinner_info = tools->info_for(spinner_session);
+
+        if (spinner_info.windows().size() > 0)
+            tools->raise_tree(spinner_info.windows()[0]);
+    }
+}
+
+void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirSurfaceState state)
+{
+    CanonicalWindowManagerPolicy::advise_state_change(window_info, state);
+
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
+    {
+        switch (state)
+        {
+        case mir_surface_state_restored:
+            titlebar->window.resize(titlebar_size_for_window(window_info.restore_rect().size));
+            titlebar->window.show();
+            break;
+
+        case mir_surface_state_maximized:
+        case mir_surface_state_vertmaximized:
+        case mir_surface_state_hidden:
+        case mir_surface_state_minimized:
+            titlebar->window.hide();
+            break;
+
+        case mir_surface_state_horizmaximized:
+            titlebar->window.resize(titlebar_size_for_window({display_area.size.width, window_info.restore_rect().size.height}));
+            titlebar->window.show();
+            break;
+
+        case mir_surface_state_fullscreen:
+        default:
+            break;
+        }
+    }
+}
+
+void TitlebarWindowManagerPolicy::advise_resize(WindowInfo const& window_info, Size const& new_size)
+{
+    CanonicalWindowManagerPolicy::advise_resize(window_info, new_size);
+
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
+    {
+        titlebar->window.resize({new_size.width, Height{title_bar_height}});
+    }
+}
+
+void TitlebarWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
+{
+    CanonicalWindowManagerPolicy::advise_delete_window(window_info);
+
+    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
+    {
+        tools->destroy(titlebar->window);
+    }
+}
+
+void TitlebarWindowManagerPolicy::handle_displays_updated(Rectangles const& displays)
+{
+    CanonicalWindowManagerPolicy::handle_displays_updated(displays);
+
+    display_area = displays.bounding_rectangle();
+}

=== added file 'miral-shell/titlebar_window_manager.h'
--- miral-shell/titlebar_window_manager.h	1970-01-01 00:00:00 +0000
+++ miral-shell/titlebar_window_manager.h	2016-06-03 15:27:17 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H
+#define MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H
+
+#include "spinner/splash.h"
+
+#include <miral/canonical_window_manager.h>
+
+using namespace mir::geometry;
+
+class TitlebarWindowManagerPolicy : public miral::CanonicalWindowManagerPolicy
+{
+public:
+    TitlebarWindowManagerPolicy(miral::WindowManagerTools* const tools, SpinnerSplash const& spinner);
+
+    bool handle_pointer_event(MirPointerEvent const* event) override;
+
+    void advise_new_window(miral::WindowInfo& window_info) override;
+    void advise_focus_lost(miral::WindowInfo const& info) override;
+    void advise_focus_gained(miral::WindowInfo const& info) override;
+    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state) override;
+    void advise_resize(miral::WindowInfo const& window_info, Size const& new_size) override;
+    void advise_delete_window(miral::WindowInfo const& window_info) override;
+
+    void handle_displays_updated(Rectangles const& displays) override;
+private:
+    miral::WindowManagerTools* const tools;
+    SpinnerSplash const spinner;
+
+    Rectangle display_area;
+    Point old_cursor{};
+};
+
+#endif //MIRAL_SHELL_TITLEBAR_WINDOW_MANAGER_H

=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-05-20 11:14:40 +0000
+++ miral/CMakeLists.txt	2016-06-03 15:27:17 +0000
@@ -5,6 +5,7 @@
 add_library(miral SHARED
     application.cpp                   ${CMAKE_SOURCE_DIR}/include/miral/application.h
     application_info.cpp              ${CMAKE_SOURCE_DIR}/include/miral/application_info.h
+    canonical_window_manager.cpp      ${CMAKE_SOURCE_DIR}/include/miral/canonical_window_manager.h
     runner.cpp                        ${CMAKE_SOURCE_DIR}/include/miral/runner.h
     display_configuration_option.cpp  ${CMAKE_SOURCE_DIR}/include/miral/display_configuration_option.h
     quit_on_ctrl_alt_bksp.cpp         ${CMAKE_SOURCE_DIR}/include/miral/quit_on_ctrl_alt_bksp.h

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2016-06-03 09:06:20 +0000
+++ miral/basic_window_manager.cpp	2016-06-03 15:27:17 +0000
@@ -29,6 +29,11 @@
 
 using namespace mir;
 
+namespace
+{
+int const title_bar_height = 10;
+}
+
 miral::BasicWindowManager::BasicWindowManager(
     shell::FocusController* focus_controller,
     std::shared_ptr<shell::DisplayLayout> const& display_layout,
@@ -91,7 +96,9 @@
         };
 
     auto& session_info = info_for(session);
-    auto& window_info = build_window(session, policy->place_new_surface(session_info, params));
+
+    auto default_placement = place_new_surface(session_info, params);
+    auto& window_info = build_window(session, policy->place_new_surface(session_info, default_placement));
 
     auto const window = window_info.window();
 
@@ -461,6 +468,219 @@
         move_tree(info_for(child), movement);
 }
 
+void miral::BasicWindowManager::modify_window(WindowInfo& window_info, WindowSpecification const& modifications)
+{
+    auto window_info_tmp = window_info;
+
+#define COPY_IF_SET(field)\
+    if (modifications.field().is_set())\
+        window_info_tmp.field(modifications.field().value())
+
+    COPY_IF_SET(type);
+    COPY_IF_SET(min_width);
+    COPY_IF_SET(min_height);
+    COPY_IF_SET(max_width);
+    COPY_IF_SET(max_height);
+    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);
+    COPY_IF_SET(preferred_orientation);
+
+#undef COPY_IF_SET
+
+    if (modifications.parent().is_set())
+        window_info_tmp.parent(info_for(modifications.parent().value()).window());
+
+    if (window_info.type() != window_info_tmp.type())
+    {
+        auto const new_type = window_info_tmp.type();
+
+        if (!window_info.can_morph_to(new_type))
+        {
+            throw std::runtime_error("Unsupported window type change");
+        }
+
+        if (window_info_tmp.must_not_have_parent())
+        {
+            if (modifications.parent().is_set())
+                throw std::runtime_error("Target window type does not support parent");
+
+            window_info_tmp.parent({});
+        }
+        else if (window_info_tmp.must_have_parent())
+        {
+            if (!window_info_tmp.parent())
+                throw std::runtime_error("Target window type requires parent");
+        }
+    }
+
+    std::swap(window_info_tmp, window_info);
+
+    auto& window = window_info.window();
+
+    if (window_info.type() != window_info_tmp.type())
+        std::shared_ptr<scene::Surface>(window)->configure(mir_surface_attrib_type, window_info.type());
+
+    if (window_info.parent() != window_info_tmp.parent())
+    {
+        if (window_info_tmp.parent())
+        {
+            auto& parent_info = info_for(window_info_tmp.parent());
+            parent_info.remove_child(window);
+        }
+
+        if (window_info.parent())
+        {
+            auto& parent_info = info_for(window_info.parent());
+            parent_info.add_child(window);
+        }
+    }
+
+    if (modifications.name().is_set())
+        std::shared_ptr<scene::Surface>(window)->rename(modifications.name().value());
+
+    if (modifications.streams().is_set())
+        window.configure_streams(modifications.streams().value());
+
+    if (modifications.input_shape().is_set())
+        std::shared_ptr<scene::Surface>(window)->set_input_region(modifications.input_shape().value());
+
+    if (modifications.size().is_set())
+    {
+        Point new_pos = window.top_left();
+        Size new_size = modifications.size().value();
+
+        window_info.constrain_resize(new_pos, new_size);
+        place_and_size(window_info, new_pos, new_size);
+    }
+    else if (modifications.min_width().is_set() || modifications.min_height().is_set() ||
+             modifications.max_width().is_set() || modifications.max_height().is_set() ||
+             modifications.width_inc().is_set() || modifications.height_inc().is_set())
+    {
+        Point new_pos = window.top_left();
+        Size new_size = window.size();
+
+        window_info.constrain_resize(new_pos, new_size);
+        place_and_size(window_info, new_pos, new_size);
+    }
+
+    if (modifications.state().is_set())
+    {
+        set_state(window_info, modifications.state().value());
+    }
+}
+
+void miral::BasicWindowManager::place_and_size(WindowInfo& root, Point const& new_pos, Size const& new_size)
+{
+    policy->advise_resize(root, new_size);
+    root.window().resize(new_size);
+    move_tree(root, new_pos - root.window().top_left());
+}
+
+void miral::BasicWindowManager::set_state(miral::WindowInfo& window_info, MirSurfaceState value)
+{
+    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:
+        window_info.window().set_state(window_info.state());
+        return;
+    }
+
+    if (window_info.state() == mir_surface_state_restored)
+    {
+        window_info.restore_rect({window_info.window().top_left(), window_info.window().size()});
+    }
+
+    if (window_info.state() != mir_surface_state_fullscreen)
+    {
+        window_info.output_id({});
+    }
+
+    if (window_info.state() == value)
+    {
+        return;
+    }
+
+    auto const old_pos = window_info.window().top_left();
+    Displacement movement;
+
+    policy->advise_state_change(window_info, value);
+
+    auto const display_area = displays.bounding_rectangle();
+
+    switch (value)
+    {
+    case mir_surface_state_restored:
+        movement = window_info.restore_rect().top_left - old_pos;
+        window_info.window().resize(window_info.restore_rect().size);
+        break;
+
+    case mir_surface_state_maximized:
+        movement = display_area.top_left - old_pos;
+        window_info.window().resize(display_area.size);
+        break;
+
+    case mir_surface_state_horizmaximized:
+        movement = Point{display_area.top_left.x, window_info.restore_rect().top_left.y} - old_pos;
+        window_info.window().resize({display_area.size.width, window_info.restore_rect().size.height});
+        break;
+
+    case mir_surface_state_vertmaximized:
+        movement = Point{window_info.restore_rect().top_left.x, display_area.top_left.y} - old_pos;
+        window_info.window().resize({window_info.restore_rect().size.width, display_area.size.height});
+        break;
+
+    case mir_surface_state_fullscreen:
+    {
+        Rectangle rect{old_pos, window_info.window().size()};
+
+        if (window_info.has_output_id())
+        {
+            place_in_output(window_info.output_id(), rect);
+        }
+        else
+        {
+            size_to_output(rect);
+        }
+
+        movement = rect.top_left - old_pos;
+        window_info.window().resize(rect.size);
+        break;
+    }
+
+    case mir_surface_state_hidden:
+    case mir_surface_state_minimized:
+        window_info.window().hide();
+        window_info.state(value);
+        window_info.window().set_state(window_info.state());
+        return;
+
+    default:
+        break;
+    }
+
+    move_tree(window_info, movement);
+
+    window_info.state(value);
+
+    if (window_info.is_visible())
+        window_info.window().show();
+
+    window_info.window().set_state(window_info.state());
+}
+
+
 void miral::BasicWindowManager::update_event_timestamp(MirKeyboardEvent const* kev)
 {
     auto iev = mir_keyboard_event_input_event(kev);
@@ -601,4 +821,159 @@
         });
 
     return new_focus;
-}
\ No newline at end of file
+}
+
+auto miral::BasicWindowManager::place_new_surface(
+    ApplicationInfo const& app_info,
+    WindowSpecification const& request_parameters)
+-> WindowSpecification
+{
+    auto parameters = request_parameters;
+    auto surf_type = parameters.type().is_set() ? parameters.type().value() : mir_surface_type_normal;
+    bool const needs_titlebar = WindowInfo::needs_titlebar(surf_type);
+
+    if (needs_titlebar)
+        parameters.size() = Size{parameters.size().value().width, parameters.size().value().height + DeltaY{title_bar_height}};
+
+    if (!parameters.state().is_set())
+        parameters.state() = mir_surface_state_restored;
+
+    auto const active_display_area = active_display();
+
+    auto const width = parameters.size().value().width.as_int();
+    auto const height = parameters.size().value().height.as_int();
+
+    bool positioned = false;
+
+    bool const has_parent{parameters.parent().is_set() && parameters.parent().value().lock()};
+
+    if (parameters.output_id().is_set() && parameters.output_id().value() != 0)
+    {
+        Rectangle rect{parameters.top_left().value(), parameters.size().value()};
+        place_in_output(parameters.output_id().value(), rect);
+        parameters.top_left() = rect.top_left;
+        parameters.size() = rect.size;
+        parameters.state() = mir_surface_state_fullscreen;
+        positioned = true;
+    }
+    else if (!has_parent) // No parent => client can't suggest positioning
+    {
+        if (app_info.windows().size() > 0)
+        {
+            if (auto const default_window = app_info.windows()[0])
+            {
+                static Displacement const offset{title_bar_height, title_bar_height};
+
+                parameters.top_left() = default_window.top_left() + offset;
+
+                Rectangle display_for_app{default_window.top_left(), default_window.size()};
+
+                size_to_output(display_for_app);
+
+                positioned = display_for_app.overlaps(Rectangle{parameters.top_left().value(), parameters.size().value()});
+            }
+        }
+    }
+
+    if (has_parent && parameters.aux_rect().is_set() && parameters.edge_attachment().is_set())
+    {
+        auto parent = info_for(parameters.parent().value()).window();
+
+        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_area.contains(top_right + Displacement{width, height}))
+            {
+                parameters.top_left() = top_right;
+                positioned = true;
+            }
+            else if (active_display_area.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_area.contains(bot_left + Displacement{width, height}))
+            {
+                parameters.top_left() = bot_left;
+                positioned = true;
+            }
+            else if (active_display_area.contains(top_left + Displacement{width, -height}))
+            {
+                parameters.top_left() = top_left + Displacement{0, -height};
+                positioned = true;
+            }
+        }
+    }
+    else if (has_parent)
+    {
+        auto parent = info_for(parameters.parent().value()).window();
+        //  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().value()))
+                             - DeltaY{(parent.size().height.as_int()-height)/6};
+
+        parameters.top_left() = centred;
+        positioned = true;
+    }
+
+    if (!positioned)
+    {
+        auto centred = active_display_area.top_left
+                       + 0.5*(as_displacement(active_display_area.size) - as_displacement(parameters.size().value()))
+                       - DeltaY{(active_display_area.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_area.top_left;
+            parameters.size() = active_display_area.size;
+            break;
+
+        case mir_surface_state_vertmaximized:
+            centred.y = active_display_area.top_left.y;
+            parameters.top_left() = centred;
+            parameters.size() = Size{parameters.size().value().width, active_display_area.size.height};
+            break;
+
+        case mir_surface_state_horizmaximized:
+            centred.x = active_display_area.top_left.x;
+            parameters.top_left() = centred;
+            parameters.size() = Size{active_display_area.size.width, parameters.size().value().height};
+            break;
+
+        default:
+            parameters.top_left() = centred;
+        }
+
+        auto const display_area = displays.bounding_rectangle();
+
+        if (parameters.top_left().value().y < display_area.top_left.y)
+            parameters.top_left() = Point{parameters.top_left().value().x, display_area.top_left.y};
+    }
+
+    if (parameters.state().value() != mir_surface_state_fullscreen && needs_titlebar)
+    {
+        parameters.top_left() = Point{parameters.top_left().value().x, parameters.top_left().value().y + DeltaY{title_bar_height}};
+        parameters.size() = Size{parameters.size().value().width, parameters.size().value().height - DeltaY{title_bar_height}};
+    }
+
+    return parameters;
+}

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-06-02 16:53:17 +0000
+++ miral/basic_window_manager.h	2016-06-03 15:27:17 +0000
@@ -38,7 +38,6 @@
 namespace shell { class DisplayLayout; }
 }
 
-/// This is based on mir/examples, but intended to move to miral after building the necessary abstractions
 namespace miral
 {
 using mir::shell::SurfaceSet;
@@ -132,7 +131,11 @@
 
     void raise_tree(Window const& root) override;
 
-    void move_tree(miral::WindowInfo& root, mir::geometry::Displacement movement) override;
+    void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override;
+
+    void place_and_size(WindowInfo& root, Point const& new_pos, Size const& new_size) override;
+
+    void set_state(miral::WindowInfo& window_info, MirSurfaceState value) override;
 
     void size_to_output(mir::geometry::Rectangle& rect) override;
 
@@ -164,6 +167,10 @@
     void update_event_timestamp(MirTouchEvent const* tev);
 
     auto can_activate_window_for_session(miral::Application const& session) -> bool;
+
+    auto place_new_surface(ApplicationInfo const& app_info, WindowSpecification const& request_parameters)
+        -> WindowSpecification;
+    void move_tree(miral::WindowInfo& root, mir::geometry::Displacement movement);
 };
 }
 

=== renamed file 'miral-shell/canonical_window_manager.cpp' => 'miral/canonical_window_manager.cpp'
--- miral-shell/canonical_window_manager.cpp	2016-06-03 09:06:20 +0000
+++ miral/canonical_window_manager.cpp	2016-06-03 15:27:17 +0000
@@ -16,56 +16,36 @@
  * Authored By: Alan Griffiths <[e-mail]>
  */
 
-#include "canonical_window_manager.h"
-#include "titlebar/canonical_window_management_policy_data.h"
-#include "spinner/splash.h"
+#include "miral/canonical_window_manager.h"
 
-#include <miral/application_info.h>
-#include <miral/window_info.h>
-#include <miral/window_manager_tools.h>
+#include "miral/application_info.h"
+#include "miral/window_info.h"
+#include "miral/window_manager_tools.h"
 
 #include <linux/input.h>
 #include <algorithm>
 #include <csignal>
 
 namespace ms = mir::scene;
-using namespace miral;
 
 // 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)
-    };
-}
-}
-
-CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy(WindowManagerTools* const tools, SpinnerSplash const& spinner) :
-    tools{tools}, spinner{spinner}
-{
-}
-
-void CanonicalWindowManagerPolicy::click(Point cursor)
+miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy(WindowManagerTools* const tools) :
+    tools{tools}
+{
+}
+
+void miral::CanonicalWindowManagerPolicy::click(Point cursor)
 {
     if (auto const window = tools->window_at(cursor))
         tools->select_active_window(window);
 }
 
-void CanonicalWindowManagerPolicy::handle_app_info_updated(Rectangles const& /*displays*/)
+void miral::CanonicalWindowManagerPolicy::handle_app_info_updated(Rectangles const& /*displays*/)
 {
 }
 
-void CanonicalWindowManagerPolicy::handle_displays_updated(Rectangles const& displays)
+void miral::CanonicalWindowManagerPolicy::handle_displays_updated(Rectangles const& displays)
 {
     display_area = displays.bounding_rectangle();
 
@@ -73,17 +53,16 @@
     {
         if (window)
         {
-            auto const& info = tools->info_for(window);
+            auto& info = tools->info_for(window);
             Rectangle rect{window.top_left(), window.size()};
 
             tools->place_in_output(info.output_id(), rect);
-            window.move_to(rect.top_left);
-            window.resize(rect.size);
+            tools->place_and_size(info, rect.top_left, rect.size);
         }
     }
 }
 
-bool CanonicalWindowManagerPolicy::resize(Point cursor)
+bool miral::CanonicalWindowManagerPolicy::resize(Point cursor)
 {
     if (!resizing)
         tools->select_active_window(tools->window_at(old_cursor));
@@ -91,423 +70,38 @@
 }
 
 
-auto CanonicalWindowManagerPolicy::place_new_surface(
-    miral::ApplicationInfo const& app_info,
+auto miral::CanonicalWindowManagerPolicy::place_new_surface(
+    miral::ApplicationInfo const& /*app_info*/,
     miral::WindowSpecification const& request_parameters)
     -> miral::WindowSpecification
 {
-    auto parameters = request_parameters;
-    auto surf_type = parameters.type().is_set() ? parameters.type().value() : mir_surface_type_normal;
-    bool const needs_titlebar = WindowInfo::needs_titlebar(surf_type);
-
-    if (needs_titlebar)
-        parameters.size() = Size{parameters.size().value().width, parameters.size().value().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().value().width.as_int();
-    auto const height = parameters.size().value().height.as_int();
-
-    bool positioned = false;
-
-    bool const has_parent{parameters.parent().is_set() && parameters.parent().value().lock()};
-
-    if (parameters.output_id().is_set() && parameters.output_id().value() != 0)
-    {
-        Rectangle rect{parameters.top_left().value(), parameters.size().value()};
-        tools->place_in_output(parameters.output_id().value(), rect);
-        parameters.top_left() = rect.top_left;
-        parameters.size() = rect.size;
-        parameters.state() = mir_surface_state_fullscreen;
-        positioned = true;
-    }
-    else if (!has_parent) // No parent => client can't suggest positioning
-    {
-        if (app_info.windows().size() > 0)
-        {
-            if (auto const default_window = app_info.windows()[0])
-            {
-                static Displacement const offset{title_bar_height, title_bar_height};
-
-                parameters.top_left() = default_window.top_left() + offset;
-
-                Rectangle display_for_app{default_window.top_left(), default_window.size()};
-
-                tools->size_to_output(display_for_app);
-
-                positioned = display_for_app.overlaps(Rectangle{parameters.top_left().value(), parameters.size().value()});
-            }
-        }
-    }
-
-    if (has_parent && parameters.aux_rect().is_set() && parameters.edge_attachment().is_set())
-    {
-        auto parent = tools->info_for(parameters.parent().value()).window();
-
-        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 (has_parent)
-    {
-        auto parent = tools->info_for(parameters.parent().value()).window();
-        //  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().value()))
-                             - DeltaY{(parent.size().height.as_int()-height)/6};
-
-        parameters.top_left() = centred;
-        positioned = true;
-    }
-
-    if (!positioned)
-    {
-        auto centred = active_display.top_left
-                             + 0.5*(as_displacement(active_display.size) - as_displacement(parameters.size().value()))
-                             - 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:
-            centred.y = active_display.top_left.y;
-            parameters.top_left() = centred;
-            parameters.size() = Size{parameters.size().value().width, active_display.size.height};
-            break;
-
-        case mir_surface_state_horizmaximized:
-            centred.x = active_display.top_left.x;
-            parameters.top_left() = centred;
-            parameters.size() = Size{active_display.size.width, parameters.size().value().height};
-            break;
-
-        default:
-            parameters.top_left() = centred;
-        }
-
-        if (parameters.top_left().value().y < display_area.top_left.y)
-            parameters.top_left() = Point{parameters.top_left().value().x, display_area.top_left.y};
-    }
-
-    if (parameters.state().value() != mir_surface_state_fullscreen && needs_titlebar)
-    {
-        parameters.top_left() = Point{parameters.top_left().value().x, parameters.top_left().value().y + DeltaY{title_bar_height}};
-        parameters.size() = Size{parameters.size().value().width, parameters.size().value().height - DeltaY{title_bar_height}};
-    }
-
-    return parameters;
-}
-
-void CanonicalWindowManagerPolicy::generate_decorations_for(WindowInfo& window_info)
-{
-    Window const& window = window_info.window();
-
-    if (!window_info.needs_titlebar(window_info.type()))
-        return;
-
-    auto format = mir_pixel_format_xrgb_8888;
-    WindowSpecification params;
-    params.size() = titlebar_size_for_window(window.size());
-    params.name() = "decoration";
-    params.pixel_format() = format;
-    params.buffer_usage() = WindowSpecification::BufferUsage::software;
-    params.top_left() = titlebar_position_for_window(window.top_left());
-    params.type() = mir_surface_type_gloss;
-
-    auto& titlebar_info = tools->build_window(window.application(), params);
-    titlebar_info.window().set_alpha(0.9);
-    titlebar_info.parent(window);
-
-    auto data = std::make_shared<CanonicalWindowManagementPolicyData>(titlebar_info.window());
-    window_info.userdata(data);
-    window_info.add_child(titlebar_info.window());
-}
-
-void CanonicalWindowManagerPolicy::advise_new_window(WindowInfo& window_info)
+    return request_parameters;
+}
+
+void miral::CanonicalWindowManagerPolicy::advise_new_window(WindowInfo& window_info)
 {
     if (window_info.state() == mir_surface_state_fullscreen)
         fullscreen_surfaces.insert(window_info.window());
-
-    generate_decorations_for(window_info);
 }
 
-void CanonicalWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
+void miral::CanonicalWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
 {
     tools->select_active_window(window_info.window());
 }
 
-void CanonicalWindowManagerPolicy::handle_modify_window(
+void miral::CanonicalWindowManagerPolicy::handle_modify_window(
     WindowInfo& window_info,
     WindowSpecification const& modifications)
 {
-    auto window_info_tmp = window_info;
-
-#define COPY_IF_SET(field)\
-        if (modifications.field().is_set())\
-            window_info_tmp.field(modifications.field().value())
-
-    COPY_IF_SET(type);
-    COPY_IF_SET(min_width);
-    COPY_IF_SET(min_height);
-    COPY_IF_SET(max_width);
-    COPY_IF_SET(max_height);
-    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);
-    COPY_IF_SET(preferred_orientation);
-
-#undef COPY_IF_SET
-
-    if (modifications.parent().is_set())
-        window_info_tmp.parent(tools->info_for(modifications.parent().value()).window());
-
-    if (window_info.type() != window_info_tmp.type())
-    {
-        auto const new_type = window_info_tmp.type();
-
-        if (!window_info.can_morph_to(new_type))
-        {
-            throw std::runtime_error("Unsupported window type change");
-        }
-
-        if (window_info_tmp.must_not_have_parent())
-        {
-            if (modifications.parent().is_set())
-                throw std::runtime_error("Target window type does not support parent");
-
-            window_info_tmp.parent({});
-        }
-        else if (window_info_tmp.must_have_parent())
-        {
-            if (!window_info_tmp.parent())
-                throw std::runtime_error("Target window type requires parent");
-        }
-    }
-
-    std::swap(window_info_tmp, window_info);
-
-    auto& window = window_info.window();
-
-    if (window_info.type() != window_info_tmp.type())
-        window.set_type(window_info.type());
-
-    if (window_info.parent() != window_info_tmp.parent())
-    {
-        if (window_info_tmp.parent())
-        {
-            auto& parent_info = tools->info_for(window_info_tmp.parent());
-            parent_info.remove_child(window);
-        }
-
-        if (window_info.parent())
-        {
-            auto& parent_info = tools->info_for(window_info.parent());
-            parent_info.add_child(window);
-        }
-    }
-
-    if (modifications.name().is_set())
-        window.rename(modifications.name().value());
-
-    if (modifications.streams().is_set())
-        window.configure_streams(modifications.streams().value());
-
-    if (modifications.input_shape().is_set())
-        window.set_input_region(modifications.input_shape().value());
-
-    if (modifications.size().is_set())
-    {
-        apply_resize(window_info, window.top_left(), modifications.size().value());
-    }
-    else if (modifications.min_width().is_set() || modifications.min_height().is_set() ||
-             modifications.max_width().is_set() || modifications.max_height().is_set() ||
-             modifications.width_inc().is_set() || modifications.height_inc().is_set())
-    {
-        apply_resize(window_info, window.top_left(), window.size());
-    }
-
-    if (modifications.state().is_set())
-        apply_set_state(window_info, modifications.state().value());
+    tools->modify_window(window_info, modifications);
 }
 
-void CanonicalWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
+void miral::CanonicalWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
 {
     fullscreen_surfaces.erase(window_info.window());
-
-    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-    {
-        tools->destroy(titlebar->window);
-    }
-}
-
-void CanonicalWindowManagerPolicy::apply_set_state(WindowInfo& window_info, MirSurfaceState value)
-{
-    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:
-        window_info.window().set_state(window_info.state());
-        return;
-    }
-
-    if (window_info.state() == mir_surface_state_restored)
-    {
-        window_info.restore_rect({window_info.window().top_left(), window_info.window().size()});
-    }
-
-    if (window_info.state() != mir_surface_state_fullscreen)
-    {
-        window_info.output_id({});
-        fullscreen_surfaces.erase(window_info.window());
-    }
-    else
-    {
-        fullscreen_surfaces.insert(window_info.window());
-    }
-
-    if (window_info.state() == value)
-    {
-        return;
-    }
-
-    auto const old_pos = window_info.window().top_left();
-    Displacement movement;
-
-    switch (value)
-    {
-    case mir_surface_state_restored:
-        movement = window_info.restore_rect().top_left - old_pos;
-        window_info.window().resize(window_info.restore_rect().size);
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-        {
-            titlebar->window.resize(titlebar_size_for_window(window_info.restore_rect().size));
-            titlebar->window.show();
-        }
-        break;
-
-    case mir_surface_state_maximized:
-        movement = display_area.top_left - old_pos;
-        window_info.window().resize(display_area.size);
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-            titlebar->window.hide();
-        break;
-
-    case mir_surface_state_horizmaximized:
-        movement = Point{display_area.top_left.x, window_info.restore_rect().top_left.y} - old_pos;
-        window_info.window().resize({display_area.size.width, window_info.restore_rect().size.height});
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-        {
-            titlebar->window.resize(titlebar_size_for_window({display_area.size.width, window_info.restore_rect().size.height}));
-            titlebar->window.show();
-        }
-        break;
-
-    case mir_surface_state_vertmaximized:
-        movement = Point{window_info.restore_rect().top_left.x, display_area.top_left.y} - old_pos;
-        window_info.window().resize({window_info.restore_rect().size.width, display_area.size.height});
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-            titlebar->window.hide();
-        break;
-
-    case mir_surface_state_fullscreen:
-    {
-        Rectangle rect{old_pos, window_info.window().size()};
-
-        if (window_info.has_output_id())
-        {
-            tools->place_in_output(window_info.output_id(), rect);
-        }
-        else
-        {
-            tools->size_to_output(rect);
-        }
-
-        movement = rect.top_left - old_pos;
-        window_info.window().resize(rect.size);
-        break;
-    }
-
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
-        if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-            titlebar->window.hide();
-        window_info.window().hide();
-        window_info.state(value);
-        window_info.window().set_state(window_info.state());
-        return;
-
-    default:
-        break;
-    }
-
-    tools->move_tree(window_info, movement);
-
-    window_info.state(value);
-
-    if (window_info.is_visible())
-        window_info.window().show();
-
-    window_info.window().set_state(window_info.state());
-    return;
-}
-
-void CanonicalWindowManagerPolicy::drag(Point cursor)
+}
+
+void miral::CanonicalWindowManagerPolicy::drag(Point cursor)
 {
     if (auto const target = tools->window_at(old_cursor))
     {
@@ -516,12 +110,12 @@
     }
 }
 
-void CanonicalWindowManagerPolicy::handle_raise_window(WindowInfo& window_info)
+void miral::CanonicalWindowManagerPolicy::handle_raise_window(WindowInfo& window_info)
 {
     tools->select_active_window(window_info.window());
 }
 
-bool CanonicalWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
+bool miral::CanonicalWindowManagerPolicy::handle_keyboard_event(MirKeyboardEvent const* event)
 {
     auto const action = mir_keyboard_event_action(event);
     auto const scan_code = mir_keyboard_event_scan_code(event);
@@ -585,7 +179,7 @@
     return false;
 }
 
-bool CanonicalWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
+bool miral::CanonicalWindowManagerPolicy::handle_touch_event(MirTouchEvent const* event)
 {
     auto const count = mir_touch_event_point_count(event);
 
@@ -642,7 +236,7 @@
     return consumes_event;
 }
 
-bool CanonicalWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
+bool miral::CanonicalWindowManagerPolicy::handle_pointer_event(MirPointerEvent const* event)
 {
     auto const action = mir_pointer_event_action(event);
     auto const modifiers = mir_pointer_event_modifiers(event) & modifier_mask;
@@ -672,35 +266,13 @@
             consumes_event = true;
         }
     }
-    else if (action == mir_pointer_action_motion && !modifiers)
-    {
-        if (mir_pointer_event_button_state(event, mir_pointer_button_primary))
-        {
-            // TODO this is a rather roundabout way to detect a titlebar
-            if (auto const possible_titlebar = tools->window_at(old_cursor))
-            {
-                if (auto const parent = tools->info_for(possible_titlebar).parent())
-                {
-                    if (auto const& parent_userdata =
-                        std::static_pointer_cast<CanonicalWindowManagementPolicyData>(tools->info_for(parent).userdata()))
-                    {
-                        if (possible_titlebar == parent_userdata->window)
-                        {
-                            drag(cursor);
-                            consumes_event = true;
-                        }
-                    }
-                }
-            }
-        }
-    }
 
     resizing = resize_event;
     old_cursor = cursor;
     return consumes_event;
 }
 
-void CanonicalWindowManagerPolicy::toggle(MirSurfaceState state)
+void miral::CanonicalWindowManagerPolicy::toggle(MirSurfaceState state)
 {
     if (auto const window = tools->active_window())
     {
@@ -709,34 +281,20 @@
         if (info.state() == state)
             state = mir_surface_state_restored;
 
-        apply_set_state(info, state);
+        tools->set_state(info, state);
     }
 }
 
-void CanonicalWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
+void miral::CanonicalWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
     tools->raise_tree(info.window());
-
-    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
-        titlebar->paint_titlebar(0xFF);
-
-    // Frig to force the spinner to the top
-    if (auto const spinner_session = spinner.session())
-    {
-        auto const& spinner_info = tools->info_for(spinner_session);
-
-        if (spinner_info.windows().size() > 0)
-            tools->raise_tree(spinner_info.windows()[0]);
-    }
 }
 
-void CanonicalWindowManagerPolicy::advise_focus_lost(WindowInfo const& info)
+void miral::CanonicalWindowManagerPolicy::advise_focus_lost(WindowInfo const& /*info*/)
 {
-    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(info.userdata()))
-        titlebar->paint_titlebar(0x3F);
 }
 
-bool CanonicalWindowManagerPolicy::resize(Window const& window, Point cursor, Point old_cursor)
+bool miral::CanonicalWindowManagerPolicy::resize(Window const& window, Point cursor, Point old_cursor)
 {
     if (!window)
         return false;
@@ -794,20 +352,24 @@
     Size new_size{new_width, new_height};
     Point new_pos = top_left + left_resize*delta.dx + top_resize*delta.dy;
 
-    apply_resize(window_info, new_pos, new_size);
+    window_info.constrain_resize(new_pos, new_size);
+    tools->place_and_size(window_info, new_pos, new_size);
 
     return true;
 }
 
-void CanonicalWindowManagerPolicy::apply_resize(WindowInfo& window_info, Point new_pos, Size new_size) const
-{
-    window_info.constrain_resize(new_pos, new_size);
-
-    if (auto const titlebar = std::static_pointer_cast<CanonicalWindowManagementPolicyData>(window_info.userdata()))
-        titlebar->window.resize({new_size.width, Height{title_bar_height}});
-
-    window_info.window().resize(new_size);
-
-    tools->move_tree(window_info, new_pos - window_info.window().top_left());
-}
-
+void miral::CanonicalWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirSurfaceState state)
+{
+    if (state != mir_surface_state_fullscreen)
+    {
+        fullscreen_surfaces.erase(window_info.window());
+    }
+    else
+    {
+        fullscreen_surfaces.insert(window_info.window());
+    }
+}
+
+void miral::CanonicalWindowManagerPolicy::advise_resize(WindowInfo const& /*window_info*/, Size const& /*new_size*/)
+{
+}

=== modified file 'miral/window.cpp'
--- miral/window.cpp	2016-04-29 13:34:54 +0000
+++ miral/window.cpp	2016-06-03 15:27:17 +0000
@@ -91,11 +91,6 @@
         surface->hide();
 }
 
-void miral::Window::reset()
-{
-    self.reset();
-}
-
 void miral::Window::set_state(MirSurfaceState state)
 {
     if (!self) return;
@@ -103,13 +98,6 @@
         surface->configure(mir_surface_attrib_state, state);
 }
 
-void miral::Window::set_type(MirSurfaceType type)
-{
-    if (!self) return;
-    if (auto const surface = self->surface.lock())
-        surface->configure(mir_surface_attrib_type, type);
-}
-
 void miral::Window::move_to(mir::geometry::Point top_left)
 {
     if (!self) return;
@@ -200,20 +188,6 @@
     }
 }
 
-void miral::Window::set_input_region(std::vector<mir::geometry::Rectangle> const& input_rectangles)
-{
-    if (!self) return;
-    if (auto const surface = self->surface.lock())
-        surface->set_input_region(input_rectangles);
-}
-
-void miral::Window::rename(std::string const& name)
-{
-    if (!self) return;
-    if (auto const surface = self->surface.lock())
-        surface->rename(name);
-}
-
 bool miral::operator==(Window const& lhs, Window const& rhs)
 {
     return lhs.self == rhs.self;