Merge lp:~alan-griffiths/miral/init-1.1 into lp:miral

[Alan Griffiths]

Init 1.1

[Gerry Boland (gerboland)]

https://launchpad.net/miral/+milestone/1.1 does not exist.
What is this bump for already?

review: Needs Information

[lp:~alan-griffiths/miral/init-1.1]

472. By Alan Griffiths on 2016-12-20

[miral-screencast] Add an option to configure the tempfile

473. By Alan Griffiths on 2016-12-20

[libmiral] remove (now) redundant visibility check

474. By Alan Griffiths on 2016-12-20

Merge changelog from release branch

475. By Alan Griffiths on 2016-12-20

[libmiral] Fix force_close() which was incorrectly locking the BasicWindowManager mutex a second time

476. By Alan Griffiths on 2016-12-20

Workaround for a missing dependency in Mir packaging

477. By Alan Griffiths on 2017-01-04

Merge changelog from release branch

478. By Alan Griffiths on 2017-01-04

[libmiral] Let the policy decide how to handle ready for windows that can't have focus

479. By Alan Griffiths on 2017-01-06

Use CMake's CMAKE_CXX_STANDARD/CMAKE_C_STANDARD instead of directly setting the -std= compiler directive

480. By Alan Griffiths on 2017-01-18

Only use -Wno-mismatched-tags when it is needed

481. By Alan Griffiths on 2017-01-18

Code compatibility with Mir 0.26

482. By Alan Griffiths on 2017-01-18

Respect the deprecations landing in lp:mir (and then 0.26)

483. By Alberto Aguirre on 2017-01-18

Address mir 0.26 changes to debug coordinate translation

484. By Alan Griffiths on 2017-01-18

Update changelog ready for 1.1 release

485. By Alan Griffiths on 2017-01-18

Fix clang builds against assorted Mir releases

486. By Alan Griffiths on 2017-01-19

More fixes to track Mir changes

487. By Alan Griffiths on 2017-01-19

[libmiral] Logging of exceptions added to --window-management-trace

488. By Alan Griffiths on 2017-01-19

Rework to respect today's Mir deprecations

489. By Alan Griffiths on 2017-01-20

Correct libmiral2.symbols

490. By Alan Griffiths on 2017-01-20

Update changelog following 1.0.2 release

491. By Alan Griffiths on 2017-01-20

Fix MIRAL_VERSION

492. By Alan Griffiths on 2017-01-23

[libmiral] top-level window is now raised along with its child (LP: #1658085)

493. By Alan Griffiths on 2017-01-24

When installing miral-examples recommend installing a cursor theme

494. By Cemil Azizoglu on 2017-01-25

Fix changed headers, address most recent deprecations.

495. By Alan Griffiths on 2017-01-26

[libmiral] Rename WindowManagementPolicy::place_new_surface => place_new_window

496. By Alan Griffiths on 2017-01-26

[libmiral] Fix compatible symbol generation when built against older Mir versions

497. By Alan Griffiths on 2017-01-26

[toolkit] rename the helper types to reflect new Mir terminology

498. By Alan Griffiths on 2017-02-03

Give miral-app and miral-desktop a good default for -bindir

499. By Alan Griffiths on 2017-02-03

[toolkit] wrapper for mir_window_spec_set_state() (LP: #1661256)

500. By Alan Griffiths on 2017-02-03

More surface to window renaming

501. By Alan Griffiths on 2017-02-03

[libmiral] Fix focus and movement rules for Input Method and Satellite windows. (LP: #1660691)

Unmerged revisions

=== modified file 'debian/changelog'
--- debian/changelog	2016-12-20 16:00:02 +0000
+++ debian/changelog	2017-01-16 17:33:11 +0000
@@ -1,3 +1,13 @@
+miral (1.1.0) UNRELEASED; urgency=medium
+
+  * New upstream release 1.1.0 (https://launchpad.net/miral/+milestone/1.1)
+    - ABI summary:
+      . miral ABI unchanged at 2
+    - Enhancements:
+    - Bugs fixed:
+
+ -- Alan Griffiths <[e-mail]>  Wed, 14 Dec 2016 16:31:08 +0000
+
 miral (1.0.1+17.04.20161220-0ubuntu1) zesty; urgency=medium
 
   * New upstream release 1.0.1 (https://launchpad.net/miral/+milestone/1.0)

=== modified file 'debian/libmiral2.symbols'
--- debian/libmiral2.symbols	2016-12-13 13:07:15 +0000
+++ debian/libmiral2.symbols	2017-01-16 17:33:11 +0000
@@ -354,4 +354,12 @@
  (c++)"typeinfo for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
  (c++)"vtable for miral::ActiveOutputsListener@MIRAL_1.0" 1.0.0
  (c++)"vtable for miral::WindowManagementPolicy@MIRAL_1.0" 1.0.0
- (c++)"vtable for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
\ No newline at end of file
+ (c++)"vtable for miral::CanonicalWindowManagerPolicy@MIRAL_1.0" 1.0.0
+ MIRAL_1.1@MIRAL_1.1 1.1.0
+ (c++)"miral::WindowInfo::needs_titlebar(MirWindowType)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::type(MirWindowType)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::type() const@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::state() const@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::state(MirWindowState)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowManagementPolicy::advise_state_change(miral::WindowInfo const&, MirWindowState)@MIRAL_1.1" 1.1.0
+ (c++)"miral::WindowInfo::can_morph_to(MirWindowType) const@MIRAL_1.1" 1.1.0

=== modified file 'include/miral/detail/mir_forward_compatibility.h'
--- include/miral/detail/mir_forward_compatibility.h	2016-09-23 13:59:34 +0000
+++ include/miral/detail/mir_forward_compatibility.h	2017-01-16 17:33:11 +0000
@@ -20,8 +20,45 @@
 #define MIRAL_MIR_FORWARD_COMPATIBILITY_H
 
 #include <mir_toolkit/version.h>
+#include <mir_toolkit/common.h>
 #include <miral/detail/mir_features.h>
 
+#if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 5, 0)
+using MirWindowAttrib = MirSurfaceAttrib;
+auto const mir_window_attrib_type                    = mir_surface_attrib_type;
+auto const mir_window_attrib_state                   = mir_surface_attrib_state;
+auto const mir_window_attrib_swapinterval            = mir_surface_attrib_swapinterval;
+auto const mir_window_attrib_focus                   = mir_surface_attrib_focus;
+auto const mir_window_attrib_dpi                     = mir_surface_attrib_dpi;
+auto const mir_window_attrib_visibility              = mir_surface_attrib_visibility;
+auto const mir_window_attrib_preferred_orientation   = mir_surface_attrib_preferred_orientation;
+auto const mir_window_attribs                        = mir_surface_attribs;
+
+using MirWindowType = MirSurfaceType;
+auto const mir_window_type_normal        = mir_surface_type_normal;
+auto const mir_window_type_utility       = mir_surface_type_utility;
+auto const mir_window_type_dialog        = mir_surface_type_dialog;
+auto const mir_window_type_gloss         = mir_surface_type_gloss;
+auto const mir_window_type_freestyle     = mir_surface_type_freestyle;
+auto const mir_window_type_menu          = mir_surface_type_menu;
+auto const mir_window_type_inputmethod   = mir_surface_type_inputmethod;
+auto const mir_window_type_satellite     = mir_surface_type_satellite;
+auto const mir_window_type_tip           = mir_surface_type_tip;
+auto const mir_window_types              = mir_surface_types;
+
+using MirWindowState = MirSurfaceState;
+auto const mir_window_state_unknown          = mir_surface_state_unknown;
+auto const mir_window_state_restored         = mir_surface_state_restored;
+auto const mir_window_state_minimized        = mir_surface_state_minimized;
+auto const mir_window_state_maximized        = mir_surface_state_maximized;
+auto const mir_window_state_vertmaximized    = mir_surface_state_vertmaximized;
+auto const mir_window_state_fullscreen       = mir_surface_state_fullscreen;
+auto const mir_window_state_horizmaximized   = mir_surface_state_horizmaximized;
+auto const mir_window_state_hidden           = mir_surface_state_hidden;
+auto const mir_window_states                 = mir_surface_states;
+#endif
+
+
 // Types that don't exist in earlier versions of Mir's toolkit
 #if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 4, 0)
 

=== modified file 'include/miral/window_info.h'
--- include/miral/window_info.h	2016-12-13 13:07:15 +0000
+++ include/miral/window_info.h	2017-01-16 17:33:11 +0000
@@ -41,7 +41,7 @@
 
     bool can_be_active() const;
 
-    bool can_morph_to(MirSurfaceType new_type) const;
+    bool can_morph_to(MirWindowType new_type) const;
 
     bool must_have_parent() const;
 
@@ -49,7 +49,7 @@
 
     bool is_visible() const;
 
-    static bool needs_titlebar(MirSurfaceType type);
+    static bool needs_titlebar(MirWindowType type);
 
     void constrain_resize(mir::geometry::Point& requested_pos, mir::geometry::Size& requested_size) const;
 
@@ -58,11 +58,11 @@
     auto name() const -> std::string;
     void name(std::string const& name);
 
-    auto type() const -> MirSurfaceType;
-    void type(MirSurfaceType type);
+    auto type() const -> MirWindowType;
+    void type(MirWindowType type);
 
-    auto state() const -> MirSurfaceState;
-    void state(MirSurfaceState state);
+    auto state() const -> MirWindowState;
+    void state(MirWindowState state);
 
     auto restore_rect() const -> mir::geometry::Rectangle;
     void restore_rect(mir::geometry::Rectangle const& restore_rect);

=== modified file 'include/miral/window_management_policy.h'
--- include/miral/window_management_policy.h	2016-12-05 09:46:35 +0000
+++ include/miral/window_management_policy.h	2017-01-16 17:33:11 +0000
@@ -23,6 +23,8 @@
 #include <mir/geometry/rectangles.h>
 #include <mir_toolkit/event.h>
 
+#include <miral/detail/mir_forward_compatibility.h>
+
 namespace miral
 {
 class Window;
@@ -141,7 +143,7 @@
      * @param window_info   the window
      * @param state         the new state
      */
-    virtual void advise_state_change(WindowInfo const& window_info, MirSurfaceState state);
+    virtual void advise_state_change(WindowInfo const& window_info, MirWindowState state);
 
     /** Notification that a window is about to move
      *

=== modified file 'include/miral/window_specification.h'
--- include/miral/window_specification.h	2016-09-30 16:29:43 +0000
+++ include/miral/window_specification.h	2017-01-16 17:33:11 +0000
@@ -76,8 +76,8 @@
     auto size() const -> mir::optional_value<Size> const&;
     auto name() const -> mir::optional_value<std::string> const&;
     auto output_id() const -> mir::optional_value<int> const&;
-    auto type() const -> mir::optional_value<MirSurfaceType> const&;
-    auto state() const -> mir::optional_value<MirSurfaceState> const&;
+    auto type() const -> mir::optional_value<MirWindowType> const&;
+    auto state() const -> mir::optional_value<MirWindowState> const&;
     auto preferred_orientation() const -> mir::optional_value<MirOrientationMode> const&;
     auto aux_rect() const -> mir::optional_value<Rectangle> const&;
     auto placement_hints() const -> mir::optional_value<MirPlacementHints> const&;
@@ -104,8 +104,8 @@
     auto size() -> mir::optional_value<Size>&;
     auto name() -> mir::optional_value<std::string>&;
     auto output_id() -> mir::optional_value<int>&;
-    auto type() -> mir::optional_value<MirSurfaceType>&;
-    auto state() -> mir::optional_value<MirSurfaceState>&;
+    auto type() -> mir::optional_value<MirWindowType>&;
+    auto state() -> mir::optional_value<MirWindowState>&;
     auto preferred_orientation() -> mir::optional_value<MirOrientationMode>&;
     auto aux_rect() -> mir::optional_value<Rectangle>&;
     auto placement_hints() -> mir::optional_value<MirPlacementHints>&;

=== modified file 'miral-kiosk/kiosk_window_manager.cpp'
--- miral-kiosk/kiosk_window_manager.cpp	2016-11-08 11:16:10 +0000
+++ miral-kiosk/kiosk_window_manager.cpp	2017-01-16 17:33:11 +0000
@@ -128,13 +128,13 @@
     // We do this here, not in place_new_surface() so that clients get a resize event.
     // This shouldn't be necessary, but works better with the gtk-mir backend.
     if (maximize_root_windows &&
-        window_info.type() == mir_surface_type_normal &&
+        window_info.type() == mir_window_type_normal &&
         !window_info.parent() &&
-        window_info.state() == mir_surface_state_restored)
+        window_info.state() == mir_window_state_restored)
     {
         WindowSpecification specification;
 
-        specification.state() = mir_surface_state_maximized;
+        specification.state() = mir_window_state_maximized;
 
         tools.place_and_size_for_state(specification, window_info);
         tools.modify_window(window_info.window(), specification);

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2016-12-22 17:30:56 +0000
+++ miral-shell/tiling_window_manager.cpp	2017-01-16 17:33:11 +0000
@@ -117,7 +117,7 @@
 
     parameters.userdata() = app_info.userdata();
     parameters.state() = parameters.state().is_set() ?
-                         transform_set_state(parameters.state().value()) : mir_surface_state_restored;
+                         transform_set_state(parameters.state().value()) : mir_window_state_restored;
 
     if (app_info.application() != spinner.session())
     {
@@ -147,13 +147,13 @@
 
 void TilingWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
 {
-    if (window_info.type() == mir_surface_type_normal &&
+    if (window_info.type() == mir_window_type_normal &&
         !window_info.parent() &&
-        window_info.state() == mir_surface_state_restored)
+        window_info.state() == mir_window_state_restored)
     {
         WindowSpecification specification;
 
-        specification.state() = mir_surface_state_maximized;
+        specification.state() = mir_window_state_maximized;
 
         tools.place_and_size_for_state(specification, window_info);
         constrain_size_and_place(specification, window_info.window(), tile_for(window_info));
@@ -229,17 +229,17 @@
         reset(mods.top_left());
 }
 
-auto TilingWindowManagerPolicy::transform_set_state(MirSurfaceState value)
--> MirSurfaceState
+auto TilingWindowManagerPolicy::transform_set_state(MirWindowState value)
+-> MirWindowState
 {
     switch (value)
     {
     default:
-        return mir_surface_state_restored;
+        return mir_window_state_restored;
 
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
-        return mir_surface_state_hidden;
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
+        return mir_window_state_hidden;
     }
 }
 
@@ -285,15 +285,15 @@
         switch (modifiers & modifier_mask)
         {
         case mir_input_event_modifier_alt:
-            toggle(mir_surface_state_maximized);
+            toggle(mir_window_state_maximized);
             return true;
 
         case mir_input_event_modifier_shift:
-            toggle(mir_surface_state_vertmaximized);
+            toggle(mir_window_state_vertmaximized);
             return true;
 
         case mir_input_event_modifier_ctrl:
-            toggle(mir_surface_state_horizmaximized);
+            toggle(mir_window_state_horizmaximized);
             return true;
 
         default:
@@ -427,14 +427,14 @@
     return consumes_event;
 }
 
-void TilingWindowManagerPolicy::toggle(MirSurfaceState state)
+void TilingWindowManagerPolicy::toggle(MirWindowState state)
 {
     if (auto window = tools.active_window())
     {
         auto& window_info = tools.info_for(window);
 
         if (window_info.state() == state)
-            state = mir_surface_state_restored;
+            state = mir_window_state_restored;
 
         WindowSpecification mods;
         mods.state() = transform_set_state(state);

=== modified file 'miral-shell/tiling_window_manager.h'
--- miral-shell/tiling_window_manager.h	2016-12-05 09:46:35 +0000
+++ miral-shell/tiling_window_manager.h	2017-01-16 17:33:11 +0000
@@ -91,14 +91,14 @@
     void click(Point cursor);
     void resize(Point cursor);
     void drag(Point cursor);
-    void toggle(MirSurfaceState state);
+    void toggle(MirWindowState state);
 
     miral::Application application_under(Point position);
 
     void update_tiles(Rectangles const& displays);
     void update_surfaces(miral::ApplicationInfo& info, Rectangle const& old_tile, Rectangle const& new_tile);
 
-    auto transform_set_state(MirSurfaceState value) -> MirSurfaceState;
+    auto transform_set_state(MirWindowState value) -> MirWindowState;
 
     static void clip_to_tile(miral::WindowSpecification& parameters, Rectangle const& tile);
     static void resize(miral::Window window, Point cursor, Point old_cursor, Rectangle bounds);

=== modified file 'miral-shell/titlebar_provider.cpp'
--- miral-shell/titlebar_provider.cpp	2016-10-27 14:07:51 +0000
+++ miral-shell/titlebar_provider.cpp	2017-01-16 17:33:11 +0000
@@ -299,23 +299,23 @@
     tools.raise_tree(window_info.parent());
 }
 
-void TitlebarProvider::advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state)
+void TitlebarProvider::advise_state_change(miral::WindowInfo const& window_info, MirWindowState state)
 {
     if (auto titlebar = find_titlebar_window(window_info.window()))
     {
         miral::WindowSpecification modifications;
         switch (state)
         {
-        case mir_surface_state_maximized:
-        case mir_surface_state_vertmaximized:
-        case mir_surface_state_hidden:
-        case mir_surface_state_minimized:
-        case mir_surface_state_fullscreen:
-            modifications.state() = mir_surface_state_hidden;
+        case mir_window_state_maximized:
+        case mir_window_state_vertmaximized:
+        case mir_window_state_hidden:
+        case mir_window_state_minimized:
+        case mir_window_state_fullscreen:
+            modifications.state() = mir_window_state_hidden;
             break;
 
         default:
-            modifications.state() = mir_surface_state_restored;
+            modifications.state() = mir_window_state_restored;
             break;
         }
 
@@ -401,4 +401,4 @@
 void Worker::stop_work()
 {
     enqueue_work([this] { work_done = true; });
-}
\ No newline at end of file
+}

=== modified file 'miral-shell/titlebar_provider.h'
--- miral-shell/titlebar_provider.h	2016-10-27 14:04:09 +0000
+++ miral-shell/titlebar_provider.h	2017-01-16 17:33:11 +0000
@@ -71,7 +71,7 @@
     void destroy_titlebar_for(miral::Window const& window);
     void resize_titlebar_for(miral::WindowInfo const& window_info, mir::geometry::Size const& size);
     void advise_new_titlebar(miral::WindowInfo const& window_info);
-    void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state);
+    void advise_state_change(miral::WindowInfo const& window_info, MirWindowState state);
 
     void stop();
 

=== modified file 'miral-shell/titlebar_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	2016-10-27 14:04:09 +0000
+++ miral-shell/titlebar_window_manager.cpp	2017-01-16 17:33:11 +0000
@@ -109,7 +109,7 @@
             }
         }
     }
-    
+
     if (resizing && !is_resize_event)
         end_resize();
 
@@ -312,7 +312,7 @@
     }
 }
 
-void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirSurfaceState state)
+void TitlebarWindowManagerPolicy::advise_state_change(WindowInfo const& window_info, MirWindowState state)
 {
     CanonicalWindowManagerPolicy::advise_state_change(window_info, state);
 
@@ -347,15 +347,15 @@
         switch (modifiers)
         {
         case mir_input_event_modifier_alt:
-            toggle(mir_surface_state_maximized);
+            toggle(mir_window_state_maximized);
             return true;
 
         case mir_input_event_modifier_shift:
-            toggle(mir_surface_state_vertmaximized);
+            toggle(mir_window_state_vertmaximized);
             return true;
 
         case mir_input_event_modifier_ctrl:
-            toggle(mir_surface_state_horizmaximized);
+            toggle(mir_window_state_horizmaximized);
             return true;
 
         default:
@@ -418,8 +418,8 @@
                 break;
 
             case KEY_UP:
-                if (window_info.state() != mir_surface_state_vertmaximized &&
-                    window_info.state() != mir_surface_state_maximized)
+                if (window_info.state() != mir_window_state_vertmaximized &&
+                    window_info.state() != mir_window_state_maximized)
                 {
                     modifications.top_left() =
                         Point{active_window.top_left().x, active_display.top_left.y} + DeltaY{title_bar_height};
@@ -455,7 +455,7 @@
     return false;
 }
 
-void TitlebarWindowManagerPolicy::toggle(MirSurfaceState state)
+void TitlebarWindowManagerPolicy::toggle(MirWindowState state)
 {
     if (auto const window = tools.active_window())
     {
@@ -463,7 +463,7 @@
 
         WindowSpecification modifications;
 
-        modifications.state() = (info.state() == state) ? mir_surface_state_restored : state;
+        modifications.state() = (info.state() == state) ? mir_window_state_restored : state;
         tools.place_and_size_for_state(modifications, info);
         tools.modify_window(info, modifications);
     }
@@ -565,7 +565,7 @@
 
     bool const needs_titlebar = WindowInfo::needs_titlebar(parameters.type().value());
 
-    if (parameters.state().value() != mir_surface_state_fullscreen && needs_titlebar)
+    if (parameters.state().value() != mir_window_state_fullscreen && needs_titlebar)
         parameters.top_left() = Point{parameters.top_left().value().x, parameters.top_left().value().y + DeltaY{title_bar_height}};
 
     if (app_info.application() == titlebar_provider->session())

=== modified file 'miral-shell/titlebar_window_manager.h'
--- miral-shell/titlebar_window_manager.h	2016-09-28 11:42:35 +0000
+++ miral-shell/titlebar_window_manager.h	2017-01-16 17:33:11 +0000
@@ -60,7 +60,7 @@
     void handle_window_ready(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_state_change(miral::WindowInfo const& window_info, MirWindowState 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;
     /** @} */
@@ -74,7 +74,7 @@
         mir_input_event_modifier_meta;
 
 private:
-    void toggle(MirSurfaceState state);
+    void toggle(MirWindowState state);
 
     bool resize(miral::Window const& window, Point cursor, Point old_cursor);
 

=== modified file 'miral/active_outputs.cpp'
--- miral/active_outputs.cpp	2016-12-13 13:07:15 +0000
+++ miral/active_outputs.cpp	2017-01-16 17:33:11 +0000
@@ -70,6 +70,11 @@
 
     void base_configuration_updated(std::shared_ptr<mir::graphics::DisplayConfiguration const> const& ) override {}
 
+    void session_configuration_applied(std::shared_ptr<mir::frontend::Session> const&,
+                                               std::shared_ptr<mir::graphics::DisplayConfiguration> const&) override {}
+
+    void session_configuration_removed(std::shared_ptr<mir::frontend::Session> const&) override {}
+
     std::mutex mutex;
     std::vector<ActiveOutputsListener*> listeners;
     std::vector<Output> outputs;

=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2017-01-04 09:19:37 +0000
+++ miral/basic_window_manager.cpp	2017-01-16 17:33:11 +0000
@@ -112,7 +112,7 @@
     if (parent)
         info_for(parent).add_child(window);
 
-    if (window_info.state() == mir_surface_state_fullscreen)
+    if (window_info.state() == mir_window_state_fullscreen)
         fullscreen_surfaces.insert(window_info.window());
 
     policy->advise_new_window(window_info);
@@ -282,35 +282,35 @@
 int miral::BasicWindowManager::set_surface_attribute(
     std::shared_ptr<scene::Session> const& /*application*/,
     std::shared_ptr<scene::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     WindowSpecification modification;
     switch (attrib)
     {
-    case mir_surface_attrib_type:
-        modification.type() = MirSurfaceType(value);
+    case mir_window_attrib_type:
+        modification.type() = MirWindowType(value);
         break;
-    case mir_surface_attrib_state:
-        modification.state() = MirSurfaceState(value);
+    case mir_window_attrib_state:
+        modification.state() = MirWindowState(value);
         break;
 
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         modification.preferred_orientation() = MirOrientationMode(value);
         break;
 
-    case mir_surface_attrib_visibility:
-        // The client really shouldn't be trying to set this.
-        // But, as the legacy API exists, we treat it as a query
-        return surface->query(mir_surface_attrib_visibility);
-
-    case mir_surface_attrib_focus:
-        // The client really shouldn't be trying to set this.
-        // But, as the legacy API exists, we treat it as a query
-        return surface->query(mir_surface_attrib_focus);
-
-    case mir_surface_attrib_swapinterval:
-    case mir_surface_attrib_dpi:
+    case mir_window_attrib_visibility:
+        // The client really shouldn't be trying to set this.
+        // But, as the legacy API exists, we treat it as a query
+        return surface->query(mir_window_attrib_visibility);
+
+    case mir_window_attrib_focus:
+        // The client really shouldn't be trying to set this.
+        // But, as the legacy API exists, we treat it as a query
+        return surface->query(mir_window_attrib_focus);
+
+    case mir_window_attrib_swapinterval:
+    case mir_window_attrib_dpi:
     default:
         return surface->configure(attrib, value);
     }
@@ -324,13 +324,13 @@
 
     switch (attrib)
     {
-    case mir_surface_attrib_type:
+    case mir_window_attrib_type:
         return info.type();
 
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
         return info.state();
 
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         return info.preferred_orientation();
         break;
 
@@ -589,7 +589,7 @@
     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());
+        std::shared_ptr<scene::Surface>(window)->configure(mir_window_attrib_type, window_info.type());
 
     if (window_info.parent() != window_info_tmp.parent())
     {
@@ -616,12 +616,12 @@
     {
         switch (window_info.state())
         {
-        case mir_surface_state_restored:
-        case mir_surface_state_hidden:
+        case mir_window_state_restored:
+        case mir_window_state_hidden:
             window_info.restore_rect({window.top_left(), window.size()});
             break;
 
-        case mir_surface_state_vertmaximized:
+        case mir_window_state_vertmaximized:
         {
             auto restore_rect = window_info.restore_rect();
             restore_rect.top_left.x = window.top_left().x;
@@ -630,7 +630,7 @@
             break;
         }
 
-        case mir_surface_state_horizmaximized:
+        case mir_window_state_horizmaximized:
         {
             auto restore_rect = window_info.restore_rect();
             restore_rect.top_left.y = window.top_left().y;
@@ -740,7 +740,7 @@
 
     switch (new_state)
     {
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
         if (modifications.output_id().is_set() &&
            (!window_info.has_output_id() || modifications.output_id().value() != window_info.output_id()))
                 break;
@@ -758,19 +758,19 @@
     // window_info.restore_rect() was cached on last state change, update to reflect current window position
     switch (window_info.state())
     {
-    case mir_surface_state_restored:
-    case mir_surface_state_hidden:
+    case mir_window_state_restored:
+    case mir_window_state_hidden:
         restore_rect = {window.top_left(), window.size()};
         break;
 
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
     {
         restore_rect.top_left.x = window.top_left().x;
         restore_rect.size.width = window.size().width;
         break;
     }
 
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
     {
         restore_rect.top_left.y = window.top_left().y;
         restore_rect.size.height= window.size().height;
@@ -793,33 +793,33 @@
 
     switch (new_state)
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         rect = restore_rect;
         break;
 
-    case mir_surface_state_maximized:
+    case mir_window_state_maximized:
         rect = display_area;
         break;
 
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         rect.top_left = {display_area.top_left.x, restore_rect.top_left.y};
         rect.size = {display_area.size.width, restore_rect.size.height};
         break;
 
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         rect.top_left = {restore_rect.top_left.x, display_area.top_left.y};
         rect.size = {restore_rect.size.width, display_area.size.height};
         break;
 
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
     {
         rect = fullscreen_rect_for(window_info);
 
         break;
     }
 
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
     default:
         return;
     }
@@ -845,12 +845,12 @@
     return r;
 }
 
-void miral::BasicWindowManager::set_state(miral::WindowInfo& window_info, MirSurfaceState value)
+void miral::BasicWindowManager::set_state(miral::WindowInfo& window_info, MirWindowState value)
 {
     auto const window = window_info.window();
     auto const mir_surface = std::shared_ptr<scene::Surface>(window);
 
-    if (value != mir_surface_state_fullscreen)
+    if (value != mir_window_state_fullscreen)
     {
         fullscreen_surfaces.erase(window);
     }
@@ -864,18 +864,18 @@
         return;
     }
 
-    bool const was_hidden = window_info.state() == mir_surface_state_hidden ||
-                            window_info.state() == mir_surface_state_minimized;
+    bool const was_hidden = window_info.state() == mir_window_state_hidden ||
+                            window_info.state() == mir_window_state_minimized;
 
     policy->advise_state_change(window_info, value);
     window_info.state(value);
 
-    mir_surface->configure(mir_surface_attrib_state, value);
+    mir_surface->configure(mir_window_attrib_state, value);
 
     switch (value)
     {
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
         mir_surface->hide();
 
         if (window == active_window())
@@ -964,7 +964,7 @@
     {
         if (std::shared_ptr<mir::scene::Surface> surface = child)
         {
-            if (surface->type() == mir_surface_type_dialog && surface->visible())
+            if (surface->type() == mir_window_type_dialog && surface->visible())
                 return select_active_window(child);
         }
     }
@@ -1007,43 +1007,43 @@
     //                              Mir and Unity: Surfaces, input, and displays (v0.3)
     switch (window_info.type())
     {
-    case mir_surface_type_normal:   // regular
-    case mir_surface_type_utility:  // floating regular
-    case mir_surface_type_dialog:   // dialog
-    case mir_surface_type_satellite:// satellite
-    case mir_surface_type_freestyle:// freestyle
+    case mir_window_type_normal:   // regular
+    case mir_window_type_utility:  // floating regular
+    case mir_window_type_dialog:   // dialog
+    case mir_window_type_satellite:// satellite
+    case mir_window_type_freestyle:// freestyle
         break;
 
-    case mir_surface_type_gloss:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_tip:
-    case mir_surface_types:
+    case mir_window_type_gloss:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:
+    case mir_window_type_tip:
+    case mir_window_types:
         return;
     }
 
     switch (window_info.state())
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         break;
 
         // "A vertically maximised window is anchored to the top and bottom of
         // the available workspace and can have any width."
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         movement.dy = DeltaY(0);
         break;
 
         // "A horizontally maximised window is anchored to the left and right of
         // the available workspace and can have any height"
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         movement.dx = DeltaX(0);
         break;
 
         // "A maximised window is anchored to the top, bottom, left and right of the
         // available workspace. For example, if the launcher is always-visible then
         // the left-edge of the window is anchored to the right-edge of the launcher."
-    case mir_surface_state_maximized:
-    case mir_surface_state_fullscreen:
+    case mir_window_state_maximized:
+    case mir_window_state_fullscreen:
     default:
         return;
     }
@@ -1069,10 +1069,10 @@
 -> WindowSpecification
 {
     if (!parameters.type().is_set())
-        parameters.type() = mir_surface_type_normal;
+        parameters.type() = mir_window_type_normal;
 
     if (!parameters.state().is_set())
-        parameters.state() = mir_surface_state_restored;
+        parameters.state() = mir_window_state_restored;
 
     auto const active_display_area = active_display();
     auto const height = parameters.size().value().height.as_int();
@@ -1088,7 +1088,7 @@
         display_layout->place_in_output(id, rect);
         parameters.top_left() = rect.top_left;
         parameters.size() = rect.size;
-        parameters.state() = mir_surface_state_fullscreen;
+        parameters.state() = mir_window_state_fullscreen;
         positioned = true;
     }
     else if (!has_parent) // No parent => client can't suggest positioning
@@ -1155,19 +1155,19 @@
 
         switch (parameters.state().value())
         {
-        case mir_surface_state_fullscreen:
-        case mir_surface_state_maximized:
+        case mir_window_state_fullscreen:
+        case mir_window_state_maximized:
             parameters.top_left() = active_display_area.top_left;
             parameters.size() = active_display_area.size;
             break;
 
-        case mir_surface_state_vertmaximized:
+        case mir_window_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:
+        case mir_window_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};
@@ -1523,37 +1523,37 @@
 
         switch (original_type)
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_satellite:
-            switch (target_type)
-            {
-            case mir_surface_type_normal:
-            case mir_surface_type_utility:
-            case mir_surface_type_dialog:
-            case mir_surface_type_satellite:
-                break;
-
-            default:
-                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
-            }
-
-        case mir_surface_type_menu:
-            switch (target_type)
-            {
-            case mir_surface_type_menu:
-            case mir_surface_type_satellite:
-                break;
-
-            default:
-                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
-            }
-
-        case mir_surface_type_gloss:
-        case mir_surface_type_freestyle:
-        case mir_surface_type_inputmethod:
-        case mir_surface_type_tip:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_satellite:
+            switch (target_type)
+            {
+            case mir_window_type_normal:
+            case mir_window_type_utility:
+            case mir_window_type_dialog:
+            case mir_window_type_satellite:
+                break;
+
+            default:
+                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
+            }
+
+        case mir_window_type_menu:
+            switch (target_type)
+            {
+            case mir_window_type_menu:
+            case mir_window_type_satellite:
+                break;
+
+            default:
+                BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
+            }
+
+        case mir_window_type_gloss:
+        case mir_window_type_freestyle:
+        case mir_window_type_inputmethod:
+        case mir_window_type_tip:
             if (target_type != original_type)
                 BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface type change"));
             break;
@@ -1565,23 +1565,23 @@
 
     switch (target_type)
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
         if (modifications.parent().is_set() ? modifications.parent().value().lock() : window_info.parent())
             BOOST_THROW_EXCEPTION(std::runtime_error("Surface type must not have a parent"));
         break;
 
-    case mir_surface_type_satellite:
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:
+    case mir_window_type_satellite:
+    case mir_window_type_gloss:
+    case mir_window_type_tip:
         if (modifications.parent().is_set() ? !modifications.parent().value().lock() : !window_info.parent())
             BOOST_THROW_EXCEPTION(std::runtime_error("Surface type must have a parent"));
         break;
 
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_dialog:
-    case mir_surface_type_menu:
-    case mir_surface_type_freestyle:
+    case mir_window_type_inputmethod:
+    case mir_window_type_dialog:
+    case mir_window_type_menu:
+    case mir_window_type_freestyle:
         break;
 
     default:

=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-12-22 17:44:19 +0000
+++ miral/basic_window_manager.h	2017-01-16 17:33:11 +0000
@@ -94,7 +94,7 @@
     int set_surface_attribute(
         std::shared_ptr<mir::scene::Session> const& /*application*/,
         std::shared_ptr<mir::scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     auto count_applications() const -> unsigned int override;
@@ -172,7 +172,7 @@
     void erase(miral::WindowInfo const& info);
     void validate_modification_request(WindowSpecification const& modifications, WindowInfo const& window_info) const;
     void place_and_size(WindowInfo& root, Point const& new_pos, Size const& new_size);
-    void set_state(miral::WindowInfo& window_info, MirSurfaceState value);
+    void set_state(miral::WindowInfo& window_info, MirWindowState value);
     auto fullscreen_rect_for(WindowInfo const& window_info) const -> Rectangle;
     void remove_window(Application const& application, miral::WindowInfo const& info);
 };

=== modified file 'miral/keymap.cpp'
--- miral/keymap.cpp	2016-10-20 07:34:53 +0000
+++ miral/keymap.cpp	2017-01-16 17:33:11 +0000
@@ -25,7 +25,10 @@
 #include <mir/server.h>
 #include <mir/version.h>
 
-#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 1)
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)
+#include <mir/input/keymap.h>
+#include <mir/input/mir_keyboard_configuration.h>
+#elif MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 24, 1)
 #include <mir/input/keymap.h>
 #include <mir/input/keyboard_configuration.h>
 #endif
@@ -112,7 +115,11 @@
 
         if (keyboard_config.is_set())
         {
+#if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)
+            keymap = keyboard_config.value().device_keymap();
+#else
             keymap = keyboard_config.value().device_keymap;
+#endif
         }
 
         keymap.layout = layout;

=== modified file 'miral/symbols.map'
--- miral/symbols.map	2016-12-13 13:07:15 +0000
+++ miral/symbols.map	2017-01-16 17:33:11 +0000
@@ -112,7 +112,6 @@
     miral::WindowInfo::WindowInfo*;
     miral::WindowInfo::add_child*;
     miral::WindowInfo::can_be_active*;
-    miral::WindowInfo::can_morph_to*;
     miral::WindowInfo::children*;
     miral::WindowInfo::confine_pointer*;
     miral::WindowInfo::constrain_resize*;
@@ -128,15 +127,12 @@
     miral::WindowInfo::must_have_parent*;
     miral::WindowInfo::must_not_have_parent*;
     miral::WindowInfo::name*;
-    miral::WindowInfo::needs_titlebar*;
     miral::WindowInfo::operator*;
     miral::WindowInfo::output_id*;
     miral::WindowInfo::parent*;
     miral::WindowInfo::preferred_orientation*;
     miral::WindowInfo::remove_child*;
     miral::WindowInfo::restore_rect*;
-    miral::WindowInfo::state*;
-    miral::WindowInfo::type*;
     miral::WindowInfo::userdata*;
     miral::WindowInfo::width_inc*;
     miral::WindowInfo::window*;
@@ -153,7 +149,6 @@
     miral::WindowManagementPolicy::advise_new_window*;
     miral::WindowManagementPolicy::advise_raise*;
     miral::WindowManagementPolicy::advise_resize*;
-    miral::WindowManagementPolicy::advise_state_change*;
     miral::WindowManagementPolicy::operator*;
     miral::WindowManagerOptions::WindowManagerOptions*;
     miral::WindowManagerOptions::operator*;
@@ -311,5 +306,45 @@
     vtable?for?miral::toolkit::Surface;
     vtable?for?miral::toolkit::SurfaceSpec;
   };
+#    miral::WindowInfo::can_morph_to*;
+    _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType;
+
+#    miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType;
+
+#    miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE15MirSurfaceState;
+
+#    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE14MirSurfaceType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+#    miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState;
 local: *;
 };
+
+MIRAL_1.1 {
+global:
+    # miral::WindowInfo::can_morph_to*
+    _ZNK5miral10WindowInfo12can_morph_toE13MirWindowType;
+
+    #miral::WindowInfo::needs_titlebar*;
+    _ZN5miral10WindowInfo14needs_titlebarE13MirWindowType;
+
+    # miral::WindowInfo::state*;
+    _ZNK5miral10WindowInfo5stateEv;
+    _ZN5miral10WindowInfo5stateE14MirWindowState;
+
+    miral::WindowInfo::type*;
+    _ZN5miral10WindowInfo4typeE13MirWindowType;
+    _ZNK5miral10WindowInfo4typeEv;
+
+    # miral::WindowManagementPolicy::advise_state_change*;
+    _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState;
+
+#  extern "C++" {
+
+#  };
+} MIRAL_1.0;

=== modified file 'miral/window_info.cpp'
--- miral/window_info.cpp	2016-12-13 13:07:15 +0000
+++ miral/window_info.cpp	2017-01-16 17:33:11 +0000
@@ -19,6 +19,7 @@
 #include "miral/window_info.h"
 
 #include <mir/scene/surface.h>
+#include <mir/version.h>
 
 #include <limits>
 
@@ -41,8 +42,8 @@
 
     Window window;
     std::string name;
-    MirSurfaceType type;
-    MirSurfaceState state;
+    MirWindowType type;
+    MirWindowState state;
     mir::geometry::Rectangle restore_rect;
     Window parent;
     std::vector <Window> children;
@@ -64,8 +65,8 @@
 miral::WindowInfo::Self::Self(Window window, WindowSpecification const& params) :
     window{window},
     name{params.name().value()},
-    type{optional_value_or_default(params.type(), mir_surface_type_normal)},
-    state{optional_value_or_default(params.state(), mir_surface_state_restored)},
+    type{optional_value_or_default(params.type(), mir_window_type_normal)},
+    state{optional_value_or_default(params.state(), mir_window_state_restored)},
     restore_rect{params.top_left().value(), params.size().value()},
     min_width{optional_value_or_default(params.min_width())},
     min_height{optional_value_or_default(params.min_height())},
@@ -86,8 +87,8 @@
 }
 
 miral::WindowInfo::Self::Self() :
-    type{mir_surface_type_normal},
-    state{mir_surface_state_unknown},
+    type{mir_window_type_normal},
+    state{mir_window_state_unknown},
     preferred_orientation{mir_orientation_mode_any}
 {
 }
@@ -123,17 +124,17 @@
 {
     switch (type())
     {
-    case mir_surface_type_normal:       /**< AKA "regular"                       */
-    case mir_surface_type_utility:      /**< AKA "floating"                      */
-    case mir_surface_type_dialog:
-    case mir_surface_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
-    case mir_surface_type_freestyle:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
+    case mir_window_type_normal:       /**< AKA "regular"                       */
+    case mir_window_type_utility:      /**< AKA "floating"                      */
+    case mir_window_type_dialog:
+    case mir_window_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
+    case mir_window_type_freestyle:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
         return true;
 
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:          /**< AKA "tooltip"                       */
+    case mir_window_type_gloss:
+    case mir_window_type_tip:          /**< AKA "tooltip"                       */
     default:
         // Cannot have input focus
         return false;
@@ -144,10 +145,10 @@
 {
     switch (type())
     {
-    case mir_surface_type_overlay:;
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_satellite:
-    case mir_surface_type_tip:
+    case mir_window_type_gloss:;
+    case mir_window_type_inputmethod:
+    case mir_window_type_satellite:
+    case mir_window_type_tip:
         return true;
 
     default:
@@ -155,19 +156,24 @@
     }
 }
 
-bool miral::WindowInfo::can_morph_to(MirSurfaceType new_type) const
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)) && (MIR_SERVER_VERSION < MIR_VERSION_NUMBER(1, 0, 0))
+extern "C" __attribute__((alias("_ZNK5miral10WindowInfo12can_morph_toE13MirWindowType"))) void _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType();
+__asm__(".symver _ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType,_ZNK5miral10WindowInfo12can_morph_toE14MirSurfaceType@MIRAL_1.0");
+__asm__(".symver _ZNK5miral10WindowInfo12can_morph_toE13MirWindowType,_ZNK5miral10WindowInfo12can_morph_toE13MirWindowType@@MIRAL_1.1");
+#endif
+bool miral::WindowInfo::can_morph_to(MirWindowType new_type) const
 {
     switch (new_type)
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
-    case mir_surface_type_satellite:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
+    case mir_window_type_satellite:
         switch (type())
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_satellite:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -175,14 +181,14 @@
         }
         break;
 
-    case mir_surface_type_dialog:
+    case mir_window_type_dialog:
         switch (type())
         {
-        case mir_surface_type_normal:
-        case mir_surface_type_utility:
-        case mir_surface_type_dialog:
-        case mir_surface_type_popover:
-        case mir_surface_type_satellite:
+        case mir_window_type_normal:
+        case mir_window_type_utility:
+        case mir_window_type_dialog:
+        case mir_window_type_menu:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -201,8 +207,8 @@
 {
     switch (type())
     {
-    case mir_surface_type_normal:
-    case mir_surface_type_utility:
+    case mir_window_type_normal:
+    case mir_window_type_utility:
         return true;
 
     default:
@@ -214,8 +220,8 @@
 {
     switch (state())
     {
-    case mir_surface_state_hidden:
-    case mir_surface_state_minimized:
+    case mir_window_state_hidden:
+    case mir_window_state_minimized:
         return false;
     default:
         if (std::shared_ptr<mir::scene::Surface> surface = window())
@@ -312,19 +318,19 @@
 
     switch (state())
     {
-    case mir_surface_state_restored:
+    case mir_window_state_restored:
         break;
 
         // "A vertically maximised window is anchored to the top and bottom of
         // the available workspace and can have any width."
-    case mir_surface_state_vertmaximized:
+    case mir_window_state_vertmaximized:
         new_pos.y = self->window.top_left().y;
         new_size.height = self->window.size().height;
         break;
 
         // "A horizontally maximised window is anchored to the left and right of
         // the available workspace and can have any height"
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_horizmaximized:
         new_pos.x = self->window.top_left().x;
         new_size.width = self->window.size().width;
         break;
@@ -332,7 +338,7 @@
         // "A maximised window is anchored to the top, bottom, left and right of the
         // available workspace. For example, if the launcher is always-visible then
         // the left-edge of the window is anchored to the right-edge of the launcher."
-    case mir_surface_state_maximized:
+    case mir_window_state_maximized:
     default:
         new_pos.x = self->window.top_left().x;
         new_pos.y = self->window.top_left().y;
@@ -345,15 +351,20 @@
     requested_size = new_size;
 }
 
-bool miral::WindowInfo::needs_titlebar(MirSurfaceType type)
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)) && (MIR_SERVER_VERSION < MIR_VERSION_NUMBER(1, 0, 0))
+extern "C" __attribute__((alias("_ZN5miral10WindowInfo14needs_titlebarE13MirWindowType"))) void _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType();
+__asm__(".symver _ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType,_ZN5miral10WindowInfo14needs_titlebarE14MirSurfaceType@MIRAL_1.0");
+__asm__(".symver _ZN5miral10WindowInfo14needs_titlebarE13MirWindowType,_ZN5miral10WindowInfo14needs_titlebarE13MirWindowType@@MIRAL_1.1");
+#endif
+bool miral::WindowInfo::needs_titlebar(MirWindowType type)
 {
     switch (type)
     {
-    case mir_surface_type_freestyle:
-    case mir_surface_type_menu:
-    case mir_surface_type_inputmethod:
-    case mir_surface_type_gloss:
-    case mir_surface_type_tip:
+    case mir_window_type_freestyle:
+    case mir_window_type_menu:
+    case mir_window_type_inputmethod:
+    case mir_window_type_gloss:
+    case mir_window_type_tip:
         // No decorations for these surface types
         return false;
     default:
@@ -361,22 +372,32 @@
     }
 }
 
-auto miral::WindowInfo::type() const -> MirSurfaceType
+auto miral::WindowInfo::type() const -> MirWindowType
 {
     return self->type;
 }
 
-void miral::WindowInfo::type(MirSurfaceType type)
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)) && (MIR_SERVER_VERSION < MIR_VERSION_NUMBER(1, 0, 0))
+extern "C" __attribute__((alias("_ZN5miral10WindowInfo4typeE13MirWindowType"))) void _ZN5miral10WindowInfo4typeE14MirSurfaceType();
+__asm__(".symver _ZN5miral10WindowInfo4typeE14MirSurfaceType,_ZN5miral10WindowInfo4typeE14MirSurfaceType@MIRAL_1.0");
+__asm__(".symver _ZN5miral10WindowInfo4typeE13MirWindowType,_ZN5miral10WindowInfo4typeE13MirWindowType@@MIRAL_1.1");
+#endif
+void miral::WindowInfo::type(MirWindowType type)
 {
     self->type = type;
 }
 
-auto miral::WindowInfo::state() const -> MirSurfaceState
+auto miral::WindowInfo::state() const -> MirWindowState
 {
     return self->state;
 }
 
-void miral::WindowInfo::state(MirSurfaceState state)
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)) && (MIR_SERVER_VERSION < MIR_VERSION_NUMBER(1, 0, 0))
+extern "C" __attribute__((alias("_ZN5miral10WindowInfo5stateE14MirWindowState"))) void _ZN5miral10WindowInfo5stateE15MirSurfaceState();
+__asm__(".symver _ZN5miral10WindowInfo5stateE15MirSurfaceState,_ZN5miral10WindowInfo5stateE15MirSurfaceState@MIRAL_1.0");
+__asm__(".symver _ZN5miral10WindowInfo5stateE14MirWindowState,_ZN5miral10WindowInfo5stateE14MirWindowState@@MIRAL_1.1");
+#endif
+void miral::WindowInfo::state(MirWindowState state)
 {
     self->state = state;
 }

=== modified file 'miral/window_management_policy.cpp'
--- miral/window_management_policy.cpp	2016-08-10 11:48:02 +0000
+++ miral/window_management_policy.cpp	2017-01-16 17:33:11 +0000
@@ -18,6 +18,8 @@
 
 #include "miral/window_management_policy.h"
 
+#include <mir/version.h>
+
 void miral::WindowManagementPolicy::advise_begin() {}
 void miral::WindowManagementPolicy::advise_end() {}
 void miral::WindowManagementPolicy::advise_new_app(ApplicationInfo& /*application*/) {}
@@ -25,7 +27,13 @@
 void miral::WindowManagementPolicy::advise_new_window(WindowInfo const& /*window_info*/) {}
 void miral::WindowManagementPolicy::advise_focus_lost(WindowInfo const& /*info*/) {}
 void miral::WindowManagementPolicy::advise_focus_gained(WindowInfo const& /*info*/) {}
-void miral::WindowManagementPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirSurfaceState /*state*/) {}
+
+#if (MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 26, 0)) && (MIR_SERVER_VERSION < MIR_VERSION_NUMBER(1, 0, 0))
+extern "C" __attribute__((alias("_ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState"))) void _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState();
+__asm__(".symver _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState,_ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE15MirSurfaceState@MIRAL_1.0");
+__asm__(".symver _ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState,_ZN5miral22WindowManagementPolicy19advise_state_changeERKNS_10WindowInfoE14MirWindowState@@MIRAL_1.1");
+#endif
+void miral::WindowManagementPolicy::advise_state_change(WindowInfo const& /*window_info*/, MirWindowState /*state*/) {}
 void miral::WindowManagementPolicy::advise_move_to(WindowInfo const& /*window_info*/, Point /*top_left*/) {}
 void miral::WindowManagementPolicy::advise_resize(WindowInfo const& /*window_info*/, Size const& /*new_size*/) {}
 void miral::WindowManagementPolicy::advise_delete_window(WindowInfo const& /*window_info*/) {}

=== modified file 'miral/window_management_trace.cpp'
--- miral/window_management_trace.cpp	2016-12-05 09:46:35 +0000
+++ miral/window_management_trace.cpp	2017-01-16 17:33:11 +0000
@@ -273,7 +273,7 @@
     return out.str();
 }
 
-auto dump_of(MirSurfaceState state) -> std::string
+auto dump_of(MirWindowState state) -> std::string
 {
     std::stringstream out;
     out << state;
@@ -606,7 +606,7 @@
     policy->advise_focus_gained(window_info);
 }
 
-void miral::WindowManagementTrace::advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state)
+void miral::WindowManagementTrace::advise_state_change(miral::WindowInfo const& window_info, MirWindowState state)
 {
     mir::log_info("%s window_info=%s, state=%s", __func__, dump_of(window_info).c_str(), dump_of(state).c_str());
     policy->advise_state_change(window_info, state);

=== modified file 'miral/window_management_trace.h'
--- miral/window_management_trace.h	2016-12-05 09:46:35 +0000
+++ miral/window_management_trace.h	2017-01-16 17:33:11 +0000
@@ -103,7 +103,7 @@
 
     virtual void advise_focus_gained(WindowInfo const& window_info) override;
 
-    virtual void advise_state_change(WindowInfo const& window_info, MirSurfaceState state) override;
+    virtual void advise_state_change(WindowInfo const& window_info, MirWindowState state) override;
 
     virtual void advise_move_to(WindowInfo const& window_info, Point top_left) override;
 

=== modified file 'miral/window_specification.cpp'
--- miral/window_specification.cpp	2016-10-25 15:07:46 +0000
+++ miral/window_specification.cpp	2017-01-16 17:33:11 +0000
@@ -37,8 +37,8 @@
     mir::optional_value<BufferUsage> buffer_usage;
     mir::optional_value<std::string> name;
     mir::optional_value<int> output_id;
-    mir::optional_value<MirSurfaceType> type;
-    mir::optional_value<MirSurfaceState> state;
+    mir::optional_value<MirWindowType> type;
+    mir::optional_value<MirWindowState> state;
     mir::optional_value<MirOrientationMode> preferred_orientation;
     mir::optional_value<BufferStreamId> content_id;
     mir::optional_value<Rectangle> aux_rect;
@@ -403,12 +403,12 @@
     return self->output_id;
 }
 
-auto miral::WindowSpecification::type() const -> mir::optional_value<MirSurfaceType> const&
+auto miral::WindowSpecification::type() const -> mir::optional_value<MirWindowType> const&
 {
     return self->type;
 }
 
-auto miral::WindowSpecification::state() const -> mir::optional_value<MirSurfaceState> const&
+auto miral::WindowSpecification::state() const -> mir::optional_value<MirWindowState> const&
 {
     return self->state;
 }
@@ -533,12 +533,12 @@
     return self->output_id;
 }
 
-auto miral::WindowSpecification::type() -> mir::optional_value<MirSurfaceType>&
+auto miral::WindowSpecification::type() -> mir::optional_value<MirWindowType>&
 {
     return self->type;
 }
 
-auto miral::WindowSpecification::state() -> mir::optional_value<MirSurfaceState>&
+auto miral::WindowSpecification::state() -> mir::optional_value<MirWindowState>&
 {
     return self->state;
 }

=== modified file 'scripts/process_doxygen_xml.py'
--- scripts/process_doxygen_xml.py	2016-12-13 13:07:15 +0000
+++ scripts/process_doxygen_xml.py	2017-01-16 17:33:11 +0000
@@ -83,11 +83,326 @@
 
 OLD_STANZAS = '''MIRAL_1.0 {
 global:
+  extern "C++" {
+    miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    miral::ActiveOutputsListener::ActiveOutputsListener*;
+    miral::ActiveOutputsListener::advise_output_begin*;
+    miral::ActiveOutputsListener::advise_output_create*;
+    miral::ActiveOutputsListener::advise_output_delete*;
+    miral::ActiveOutputsListener::advise_output_end*;
+    miral::ActiveOutputsListener::advise_output_update*;
+    miral::ActiveOutputsListener::operator*;
+    miral::ActiveOutputsMonitor::?ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::ActiveOutputsMonitor*;
+    miral::ActiveOutputsMonitor::add_listener*;
+    miral::ActiveOutputsMonitor::delete_listener*;
+    miral::ActiveOutputsMonitor::operator*;
+    miral::ActiveOutputsMonitor::process_outputs*;
+    miral::AddInitCallback::?AddInitCallback*;
+    miral::AddInitCallback::AddInitCallback*;
+    miral::AddInitCallback::operator*;
+    miral::AppendEventFilter::AppendEventFilter*;
+    miral::AppendEventFilter::operator*;
+    miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::ApplicationAuthorizer*;
+    miral::ApplicationAuthorizer::operator*;
+    miral::ApplicationCredentials::ApplicationCredentials*;
+    miral::ApplicationCredentials::gid*;
+    miral::ApplicationCredentials::pid*;
+    miral::ApplicationCredentials::uid*;
+    miral::ApplicationInfo::?ApplicationInfo*;
+    miral::ApplicationInfo::ApplicationInfo*;
+    miral::ApplicationInfo::add_window*;
+    miral::ApplicationInfo::application*;
+    miral::ApplicationInfo::name*;
+    miral::ApplicationInfo::operator*;
+    miral::ApplicationInfo::remove_window*;
+    miral::ApplicationInfo::userdata*;
+    miral::ApplicationInfo::windows*;
+    miral::BasicSetApplicationAuthorizer::?BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::BasicSetApplicationAuthorizer*;
+    miral::BasicSetApplicationAuthorizer::operator*;
+    miral::BasicSetApplicationAuthorizer::the_application_authorizer*;
+    miral::CanonicalWindowManagerPolicy::CanonicalWindowManagerPolicy*;
+    miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    miral::CanonicalWindowManagerPolicy::confirm_inherited_move*;
+    miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    miral::CommandLineOption::?CommandLineOption*;
+    miral::CommandLineOption::CommandLineOption*;
+    miral::CommandLineOption::operator*;
+    miral::CursorTheme::?CursorTheme*;
+    miral::CursorTheme::CursorTheme*;
+    miral::CursorTheme::operator*;
+    miral::DebugExtension::DebugExtension*;
+    miral::DebugExtension::disable*;
+    miral::DebugExtension::enable*;
+    miral::DebugExtension::operator*;
+    miral::InternalClientLauncher::?InternalClientLauncher*;
+    miral::InternalClientLauncher::InternalClientLauncher*;
+    miral::InternalClientLauncher::launch*;
+    miral::InternalClientLauncher::operator*;
+    miral::Keymap::?Keymap*;
+    miral::Keymap::Keymap*;
+    miral::Keymap::operator*;
+    miral::Keymap::set_keymap*;
+    miral::MirRunner::?MirRunner*;
+    miral::MirRunner::MirRunner*;
+    miral::MirRunner::add_start_callback*;
+    miral::MirRunner::add_stop_callback*;
+    miral::MirRunner::run_with*;
+    miral::MirRunner::set_exception_handler*;
+    miral::MirRunner::stop*;
+    miral::Output::?Output*;
+    miral::Output::Output*;
+    miral::Output::connected*;
+    miral::Output::extents*;
+    miral::Output::form_factor*;
+    miral::Output::is_same_output*;
+    miral::Output::operator*;
+    miral::Output::orientation*;
+    miral::Output::physical_size_mm*;
+    miral::Output::pixel_format*;
+    miral::Output::power_mode*;
+    miral::Output::refresh_rate*;
+    miral::Output::scale*;
+    miral::Output::type*;
+    miral::Output::used*;
+    miral::Output::valid*;
+    miral::SetCommandLineHandler::?SetCommandLineHandler*;
+    miral::SetCommandLineHandler::SetCommandLineHandler*;
+    miral::SetCommandLineHandler::operator*;
+    miral::SetTerminator::?SetTerminator*;
+    miral::SetTerminator::SetTerminator*;
+    miral::SetTerminator::operator*;
+    miral::SetWindowManagmentPolicy::?SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::SetWindowManagmentPolicy*;
+    miral::SetWindowManagmentPolicy::operator*;
+    miral::StartupInternalClient::?StartupInternalClient*;
+    miral::StartupInternalClient::StartupInternalClient*;
+    miral::StartupInternalClient::operator*;
+    miral::Window::?Window*;
+    miral::Window::Window*;
+    miral::Window::application*;
+    miral::Window::move_to*;
+    miral::Window::operator*;
+    miral::Window::resize*;
+    miral::Window::size*;
+    miral::Window::top_left*;
+    miral::WindowInfo::?WindowInfo*;
+    miral::WindowInfo::WindowInfo*;
+    miral::WindowInfo::add_child*;
+    miral::WindowInfo::can_be_active*;
+    miral::WindowInfo::can_morph_to*;
+    miral::WindowInfo::children*;
+    miral::WindowInfo::confine_pointer*;
+    miral::WindowInfo::constrain_resize*;
+    miral::WindowInfo::has_output_id*;
+    miral::WindowInfo::height_inc*;
+    miral::WindowInfo::is_visible*;
+    miral::WindowInfo::max_aspect*;
+    miral::WindowInfo::max_height*;
+    miral::WindowInfo::max_width*;
+    miral::WindowInfo::min_aspect*;
+    miral::WindowInfo::min_height*;
+    miral::WindowInfo::min_width*;
+    miral::WindowInfo::must_have_parent*;
+    miral::WindowInfo::must_not_have_parent*;
+    miral::WindowInfo::name*;
+    miral::WindowInfo::needs_titlebar*;
+    miral::WindowInfo::operator*;
+    miral::WindowInfo::output_id*;
+    miral::WindowInfo::parent*;
+    miral::WindowInfo::preferred_orientation*;
+    miral::WindowInfo::remove_child*;
+    miral::WindowInfo::restore_rect*;
+    miral::WindowInfo::state*;
+    miral::WindowInfo::type*;
+    miral::WindowInfo::userdata*;
+    miral::WindowInfo::width_inc*;
+    miral::WindowInfo::window*;
+    miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    miral::WindowManagementPolicy::WindowManagementPolicy*;
+    miral::WindowManagementPolicy::advise_begin*;
+    miral::WindowManagementPolicy::advise_delete_app*;
+    miral::WindowManagementPolicy::advise_delete_window*;
+    miral::WindowManagementPolicy::advise_end*;
+    miral::WindowManagementPolicy::advise_focus_gained*;
+    miral::WindowManagementPolicy::advise_focus_lost*;
+    miral::WindowManagementPolicy::advise_move_to*;
+    miral::WindowManagementPolicy::advise_new_app*;
+    miral::WindowManagementPolicy::advise_new_window*;
+    miral::WindowManagementPolicy::advise_raise*;
+    miral::WindowManagementPolicy::advise_resize*;
+    miral::WindowManagementPolicy::advise_state_change*;
+    miral::WindowManagementPolicy::operator*;
+    miral::WindowManagerOptions::WindowManagerOptions*;
+    miral::WindowManagerOptions::operator*;
+    miral::WindowManagerTools::?WindowManagerTools*;
+    miral::WindowManagerTools::WindowManagerTools*;
+    miral::WindowManagerTools::active_display*;
+    miral::WindowManagerTools::active_window*;
+    miral::WindowManagerTools::ask_client_to_close*;
+    miral::WindowManagerTools::count_applications*;
+    miral::WindowManagerTools::drag_active_window*;
+    miral::WindowManagerTools::find_application*;
+    miral::WindowManagerTools::focus_next_application*;
+    miral::WindowManagerTools::focus_next_within_application*;
+    miral::WindowManagerTools::for_each_application*;
+    miral::WindowManagerTools::force_close*;
+    miral::WindowManagerTools::id_for_window*;
+    miral::WindowManagerTools::info_for*;
+    miral::WindowManagerTools::info_for_window_id*;
+    miral::WindowManagerTools::invoke_under_lock*;
+    miral::WindowManagerTools::modify_window*;
+    miral::WindowManagerTools::operator*;
+    miral::WindowManagerTools::place_and_size_for_state*;
+    miral::WindowManagerTools::raise_tree*;
+    miral::WindowManagerTools::select_active_window*;
+    miral::WindowManagerTools::window_at*;
+    miral::WindowSpecification::?WindowSpecification*;
+    miral::WindowSpecification::WindowSpecification*;
+    miral::WindowSpecification::aux_rect*;
+    miral::WindowSpecification::aux_rect_placement_gravity*;
+    miral::WindowSpecification::aux_rect_placement_offset*;
+    miral::WindowSpecification::confine_pointer*;
+    miral::WindowSpecification::height_inc*;
+    miral::WindowSpecification::input_mode*;
+    miral::WindowSpecification::input_shape*;
+    miral::WindowSpecification::max_aspect*;
+    miral::WindowSpecification::max_height*;
+    miral::WindowSpecification::max_width*;
+    miral::WindowSpecification::min_aspect*;
+    miral::WindowSpecification::min_height*;
+    miral::WindowSpecification::min_width*;
+    miral::WindowSpecification::name*;
+    miral::WindowSpecification::operator*;
+    miral::WindowSpecification::output_id*;
+    miral::WindowSpecification::parent*;
+    miral::WindowSpecification::placement_hints*;
+    miral::WindowSpecification::preferred_orientation*;
+    miral::WindowSpecification::shell_chrome*;
+    miral::WindowSpecification::size*;
+    miral::WindowSpecification::state*;
+    miral::WindowSpecification::top_left*;
+    miral::WindowSpecification::type*;
+    miral::WindowSpecification::update*;
+    miral::WindowSpecification::userdata*;
+    miral::WindowSpecification::width_inc*;
+    miral::WindowSpecification::window_placement_gravity*;
+    miral::apply_lifecycle_state_to*;
+    miral::display_configuration_options*;
+    miral::equivalent_display_area*;
+    miral::kill*;
+    miral::name_of*;
+    miral::operator*;
+    miral::pid_of*;
+    miral::toolkit::Connection::Connection*;
+    miral::toolkit::Surface::Surface*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::?ActiveOutputsListener*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_begin*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_create*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_delete*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_end*;
+    non-virtual?thunk?to?miral::ActiveOutputsListener::advise_output_update*;
+    non-virtual?thunk?to?miral::ApplicationAuthorizer::?ApplicationAuthorizer*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::confirm_inherited_move*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_modify_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_raise_window*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::handle_window_ready*;
+    non-virtual?thunk?to?miral::CanonicalWindowManagerPolicy::place_new_surface*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::?WindowManagementPolicy*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_begin*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_delete_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_end*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_gained*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_focus_lost*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_move_to*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_app*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_new_window*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_raise*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_resize*;
+    non-virtual?thunk?to?miral::WindowManagementPolicy::advise_state_change*;
+    typeinfo?for?miral::ActiveOutputsListener;
+    typeinfo?for?miral::ActiveOutputsMonitor;
+    typeinfo?for?miral::AddInitCallback;
+    typeinfo?for?miral::AppendEventFilter;
+    typeinfo?for?miral::ApplicationAuthorizer;
+    typeinfo?for?miral::ApplicationCredentials;
+    typeinfo?for?miral::ApplicationInfo;
+    typeinfo?for?miral::BasicSetApplicationAuthorizer;
+    typeinfo?for?miral::CanonicalWindowManagerPolicy;
+    typeinfo?for?miral::CommandLineOption;
+    typeinfo?for?miral::CursorTheme;
+    typeinfo?for?miral::DebugExtension;
+    typeinfo?for?miral::InternalClientLauncher;
+    typeinfo?for?miral::Keymap;
+    typeinfo?for?miral::MirRunner;
+    typeinfo?for?miral::Output;
+    typeinfo?for?miral::Output::PhysicalSizeMM;
+    typeinfo?for?miral::SetCommandLineHandler;
+    typeinfo?for?miral::SetTerminator;
+    typeinfo?for?miral::SetWindowManagmentPolicy;
+    typeinfo?for?miral::StartupInternalClient;
+    typeinfo?for?miral::Window;
+    typeinfo?for?miral::WindowInfo;
+    typeinfo?for?miral::WindowManagementPolicy;
+    typeinfo?for?miral::WindowManagerOption;
+    typeinfo?for?miral::WindowManagerOptions;
+    typeinfo?for?miral::WindowManagerTools;
+    typeinfo?for?miral::WindowSpecification;
+    typeinfo?for?miral::WindowSpecification::AspectRatio;
+    typeinfo?for?miral::toolkit::Connection;
+    typeinfo?for?miral::toolkit::PersistentId;
+    typeinfo?for?miral::toolkit::Surface;
+    typeinfo?for?miral::toolkit::SurfaceSpec;
+    vtable?for?miral::ActiveOutputsListener;
+    vtable?for?miral::ActiveOutputsMonitor;
+    vtable?for?miral::AddInitCallback;
+    vtable?for?miral::AppendEventFilter;
+    vtable?for?miral::ApplicationAuthorizer;
+    vtable?for?miral::ApplicationCredentials;
+    vtable?for?miral::ApplicationInfo;
+    vtable?for?miral::BasicSetApplicationAuthorizer;
+    vtable?for?miral::CanonicalWindowManagerPolicy;
+    vtable?for?miral::CommandLineOption;
+    vtable?for?miral::CursorTheme;
+    vtable?for?miral::DebugExtension;
+    vtable?for?miral::InternalClientLauncher;
+    vtable?for?miral::Keymap;
+    vtable?for?miral::MirRunner;
+    vtable?for?miral::Output;
+    vtable?for?miral::Output::PhysicalSizeMM;
+    vtable?for?miral::SetCommandLineHandler;
+    vtable?for?miral::SetTerminator;
+    vtable?for?miral::SetWindowManagmentPolicy;
+    vtable?for?miral::StartupInternalClient;
+    vtable?for?miral::Window;
+    vtable?for?miral::WindowInfo;
+    vtable?for?miral::WindowManagementPolicy;
+    vtable?for?miral::WindowManagerOption;
+    vtable?for?miral::WindowManagerOptions;
+    vtable?for?miral::WindowManagerTools;
+    vtable?for?miral::WindowSpecification;
+    vtable?for?miral::WindowSpecification::AspectRatio;
+    vtable?for?miral::toolkit::Connection;
+    vtable?for?miral::toolkit::PersistentId;
+    vtable?for?miral::toolkit::Surface;
+    vtable?for?miral::toolkit::SurfaceSpec;
+  };
+local: *;
+};
+
+MIRAL_1.1 {
+global:
   extern "C++" {'''
 
 END_NEW_STANZA = '''  };
-local: *;
-};'''
+} MIRAL_1.0;'''
 
 def _print_report():
     print OLD_STANZAS

=== modified file 'test/display_reconfiguration.cpp'
--- test/display_reconfiguration.cpp	2016-11-10 17:25:38 +0000
+++ test/display_reconfiguration.cpp	2017-01-16 17:33:11 +0000
@@ -51,9 +51,9 @@
     void create_fullscreen_window()
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
-        creation_parameters.type = mir_surface_type_normal;
+        creation_parameters.type = mir_window_type_normal;
         creation_parameters.size = initial_window_size;
-        creation_parameters.state = mir_surface_state_fullscreen;
+        creation_parameters.state = mir_window_state_fullscreen;
         creation_parameters.output_id = mir::graphics::DisplayConfigurationOutputId{0};
 
         EXPECT_CALL(*window_manager_policy, advise_new_window(_))
@@ -77,9 +77,9 @@
     create_fullscreen_window();
 
     WindowSpecification mods;
-    mods.state() = mir_surface_state_hidden;
+    mods.state() = mir_window_state_hidden;
     window_manager_tools.modify_window(window, mods);
-    mods.state() = mir_surface_state_fullscreen;
+    mods.state() = mir_window_state_fullscreen;
     window_manager_tools.modify_window(window, mods);
 
     Rectangle const new_display{display_area.top_left+as_displacement({display_width, Height{0}}), display_area.size};

=== modified file 'test/drag_active_window.cpp'
--- test/drag_active_window.cpp	2016-11-07 12:09:04 +0000
+++ test/drag_active_window.cpp	2017-01-16 17:33:11 +0000
@@ -36,7 +36,7 @@
 
 auto const null_window = Window{};
 
-struct DragActiveWindow : TestWindowManagerTools, WithParamInterface<MirSurfaceType>
+struct DragActiveWindow : TestWindowManagerTools, WithParamInterface<MirWindowType>
 {
     Size const initial_parent_size{600, 400};
 
@@ -48,7 +48,7 @@
         basic_window_manager.add_session(session);
     }
 
-    void create_window_of_type(MirSurfaceType type)
+    void create_window_of_type(MirWindowType type)
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
         creation_parameters.type = type;

=== modified file 'test/modify_window_state.cpp'
--- test/modify_window_state.cpp	2016-11-07 12:09:11 +0000
+++ test/modify_window_state.cpp	2017-01-16 17:33:11 +0000
@@ -36,7 +36,7 @@
 
 auto const null_window = Window{};
 
-struct ModifyWindowState : TestWindowManagerTools, WithParamInterface<MirSurfaceType>
+struct ModifyWindowState : TestWindowManagerTools, WithParamInterface<MirWindowType>
 {
     Size const initial_parent_size{600, 400};
 
@@ -48,7 +48,7 @@
         basic_window_manager.add_session(session);
     }
 
-    void create_window_of_type(MirSurfaceType type)
+    void create_window_of_type(MirWindowType type)
     {
         mir::scene::SurfaceCreationParameters creation_parameters;
         creation_parameters.type = type;
@@ -72,11 +72,11 @@
 
 TEST_P(ForNormalSurface, state)
 {
-    auto const original_state = mir_surface_state_restored;
-    auto const new_state = MirSurfaceState(GetParam());
-    auto const state_is_visible = (new_state != mir_surface_state_minimized) && (new_state != mir_surface_state_hidden);
+    auto const original_state = mir_window_state_restored;
+    auto const new_state = MirWindowState(GetParam());
+    auto const state_is_visible = (new_state != mir_window_state_minimized) && (new_state != mir_window_state_hidden);
 
-    create_window_of_type(mir_surface_type_normal);
+    create_window_of_type(mir_window_type_normal);
     auto const& info = window_manager_tools.info_for(window);
 
     WindowSpecification mods;
@@ -95,13 +95,13 @@
 }
 
 INSTANTIATE_TEST_CASE_P(ModifyWindowState, ForNormalSurface, ::testing::Values(
-//    mir_surface_state_unknown,
-    mir_surface_state_restored,
-    mir_surface_state_minimized,
-    mir_surface_state_maximized,
-    mir_surface_state_vertmaximized,
-    mir_surface_state_fullscreen,
-    mir_surface_state_horizmaximized,
-    mir_surface_state_hidden
-//    mir_surface_states
+//    mir_window_state_unknown,
+    mir_window_state_restored,
+    mir_window_state_minimized,
+    mir_window_state_maximized,
+    mir_window_state_vertmaximized,
+    mir_window_state_fullscreen,
+    mir_window_state_horizmaximized,
+    mir_window_state_hidden
+//    mir_window_states
 ));

=== modified file 'test/select_active_window.cpp'
--- test/select_active_window.cpp	2016-10-10 14:53:39 +0000
+++ test/select_active_window.cpp	2017-01-16 17:33:11 +0000
@@ -82,13 +82,13 @@
 {
     mir::scene::SurfaceCreationParameters creation_parameters;
     creation_parameters.name = "parent";
-    creation_parameters.type = mir_surface_type_normal;
+    creation_parameters.type = mir_window_type_normal;
     creation_parameters.size = Size{600, 400};
 
     auto parent = create_window(creation_parameters);
 
     creation_parameters.name = "dialog";
-    creation_parameters.type = mir_surface_type_dialog;
+    creation_parameters.type = mir_window_type_dialog;
     creation_parameters.parent = parent;
 
     auto dialog = create_window(creation_parameters);
@@ -102,22 +102,22 @@
 {
     mir::scene::SurfaceCreationParameters creation_parameters;
     creation_parameters.name = "parent";
-    creation_parameters.type = mir_surface_type_normal;
+    creation_parameters.type = mir_window_type_normal;
     creation_parameters.size = Size{600, 400};
 
     auto parent = create_window(creation_parameters);
 
     creation_parameters.name = "dialog";
-    creation_parameters.type = mir_surface_type_dialog;
+    creation_parameters.type = mir_window_type_dialog;
     creation_parameters.parent = parent;
 
     auto dialog = create_window(creation_parameters);
 
     WindowSpecification mods;
-    mods.state() = mir_surface_state_hidden;
+    mods.state() = mir_window_state_hidden;
     basic_window_manager.modify_window(basic_window_manager.info_for(dialog), mods);
 
     auto actual = basic_window_manager.select_active_window(parent);
     EXPECT_THAT(actual, Eq(parent))
                 << "actual=" << actual << ", expected=" << parent;
-}
\ No newline at end of file
+}

=== modified file 'test/test_window_manager_tools.h'
--- test/test_window_manager_tools.h	2016-10-10 14:53:39 +0000
+++ test/test_window_manager_tools.h	2017-01-16 17:33:11 +0000
@@ -74,11 +74,11 @@
 
 struct StubSurface : mir::test::doubles::StubSurface
 {
-    StubSurface(std::string name, MirSurfaceType type, mir::geometry::Point top_left, mir::geometry::Size size) :
+    StubSurface(std::string name, MirWindowType type, mir::geometry::Point top_left, mir::geometry::Size size) :
         name_{name}, type_{type}, top_left_{top_left}, size_{size} {}
 
     std::string name() const override { return name_; };
-    MirSurfaceType type() const { return type_; }
+    MirWindowType type() const { return type_; }
 
     mir::geometry::Point top_left() const override { return top_left_; }
     void move_to(mir::geometry::Point const& top_left) override { top_left_ = top_left; }
@@ -86,25 +86,25 @@
     mir::geometry::Size size() const override { return  size_; }
     void resize(mir::geometry::Size const& size) override { size_ = size; }
 
-    auto state() const -> MirSurfaceState override { return state_; }
-    auto configure(MirSurfaceAttrib attrib, int value) -> int override {
+    auto state() const -> MirWindowState override { return state_; }
+    auto configure(MirWindowAttrib attrib, int value) -> int override {
         switch (attrib)
         {
-        case mir_surface_attrib_state:
-            state_ = MirSurfaceState(value);
+        case mir_window_attrib_state:
+            state_ = MirWindowState(value);
             return state_;
         default:
             return value;
         }
     }
 
-    bool visible() const override { return  state() != mir_surface_state_hidden; }
+    bool visible() const override { return  state() != mir_window_state_hidden; }
 
     std::string name_;
-    MirSurfaceType type_;
+    MirWindowType type_;
     mir::geometry::Point top_left_;
     mir::geometry::Size size_;
-    MirSurfaceState state_ = mir_surface_state_restored;
+    MirWindowState state_ = mir_window_state_restored;
 };
 
 struct StubStubSession : mir::test::doubles::StubSession

=== modified file 'test/window_placement.cpp'
--- test/window_placement.cpp	2016-09-19 12:04:12 +0000
+++ test/window_placement.cpp	2017-01-16 17:33:11 +0000
@@ -73,7 +73,7 @@
         creation_parameters.size = initial_parent_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
 
-        creation_parameters.type = mir_surface_type_menu;
+        creation_parameters.type = mir_window_type_menu;
         creation_parameters.parent = parent;
         creation_parameters.size = initial_child_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
@@ -121,12 +121,12 @@
     ASSERT_THAT(parent, Ne(null_window));
     ASSERT_THAT(parent.size(), Eq(initial_parent_size));
     ASSERT_THAT(basic_window_manager.info_for(parent).children(), ElementsAre(child));
-    ASSERT_THAT(basic_window_manager.info_for(parent).type(), Eq(mir_surface_type_normal));
+    ASSERT_THAT(basic_window_manager.info_for(parent).type(), Eq(mir_window_type_normal));
 
     ASSERT_THAT(child, Ne(null_window));
     ASSERT_THAT(child.size(), Eq(initial_child_size));
     ASSERT_THAT(basic_window_manager.info_for(child).parent(), Eq(parent));
-    ASSERT_THAT(basic_window_manager.info_for(child).type(), Eq(mir_surface_type_menu));
+    ASSERT_THAT(basic_window_manager.info_for(child).type(), Eq(mir_window_type_menu));
 }
 
 

=== modified file 'test/window_placement_anchors_to_parent.cpp'
--- test/window_placement_anchors_to_parent.cpp	2016-09-19 14:06:02 +0000
+++ test/window_placement_anchors_to_parent.cpp	2017-01-16 17:33:11 +0000
@@ -71,7 +71,7 @@
         creation_parameters.size = parent_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);
 
-        creation_parameters.type = mir_surface_type_tip;
+        creation_parameters.type = mir_window_type_tip;
         creation_parameters.parent = parent;
         creation_parameters.size = initial_child_size;
         basic_window_manager.add_surface(session, creation_parameters, &create_surface);