Merge lp:~brandontschaefer/mir/usr-mir-window-placement into lp:mir

[Brandon Schaefer]

Use MirWindowPlacementEvent vs MirSurfacePlacement

Use MirWindowPlacementEvent vs MirSurfacePlacement

=== modified file 'examples/client_touch_validator.cpp'
--- examples/client_touch_validator.cpp	2017-01-09 06:48:47 +0000
+++ examples/client_touch_validator.cpp	2017-01-10 20:52:04 +0000
@@ -143,7 +143,7 @@
     case mir_event_type_input:
         on_input_event(state, mir_event_get_input_event(event));
         break;
-    case mir_event_type_close_surface:
+    case mir_event_type_close_window:
         abort();
         break;
     default:
 
=== modified file 'examples/eglapp.c'
--- examples/eglapp.c	2017-01-09 06:48:47 +0000
+++ examples/eglapp.c	2017-01-10 20:52:04 +0000
@@ -110,18 +110,18 @@
     running = 0;
 }
 
-static void mir_eglapp_handle_surface_event(MirSurfaceEvent const* sev)
+static void mir_eglapp_handle_window_event(MirWindowEvent const* sev)
 {
-    MirSurfaceAttrib attrib = mir_surface_event_get_attribute(sev);
-    int value = mir_surface_event_get_attribute_value(sev);
+    MirWindowAttrib attrib = mir_window_event_get_attribute(sev);
+    int value = mir_window_event_get_attribute_value(sev);
 
     switch (attrib)
     {
-    case mir_surface_attrib_visibility:
+    case mir_window_attrib_visibility:
         printf("Window %s\n", value == mir_surface_visibility_exposed ?
                                "exposed" : "occluded");
         break;
-    case mir_surface_attrib_dpi:
+    case mir_window_attrib_dpi:
         // value is still zero - never implemented. Deprecate? (LP: #1559831)
         break;
     default:
@@ -129,19 +129,19 @@
     }
 }
 
-static void handle_surface_output_event(MirSurfaceOutputEvent const* out)
+static void handle_window_output_event(MirWindowOutputEvent const* out)
 {
     static char const* const form_factor_name[6] =
         {"unknown", "phone", "tablet", "monitor", "TV", "projector"};
-    unsigned ff = mir_surface_output_event_get_form_factor(out);
+    unsigned ff = mir_window_output_event_get_form_factor(out);
     char const* form_factor = (ff < 6) ? form_factor_name[ff] : "out-of-range";
 
-    refresh_rate = mir_surface_output_event_get_refresh_rate(out);
+    refresh_rate = mir_window_output_event_get_refresh_rate(out);
 
     printf("Window is on output %u: %d DPI, scale %.1fx, %s form factor, %.2fHz\n",
-           mir_surface_output_event_get_output_id(out),
-           mir_surface_output_event_get_dpi(out),
-           mir_surface_output_event_get_scale(out),
+           mir_window_output_event_get_output_id(out),
+           mir_window_output_event_get_dpi(out),
+           mir_window_output_event_get_scale(out),
            form_factor,
            refresh_rate);
 }
@@ -161,11 +161,11 @@
     case mir_event_type_input:
         mir_eglapp_handle_input_event(mir_event_get_input_event(ev));
         break;
-    case mir_event_type_surface:
-        mir_eglapp_handle_surface_event(mir_event_get_surface_event(ev));
+    case mir_event_type_window:
+        mir_eglapp_handle_window_event(mir_event_get_window_event(ev));
         break;
-    case mir_event_type_surface_output:
-        handle_surface_output_event(mir_event_get_surface_output_event(ev));
+    case mir_event_type_window_output:
+        handle_window_output_event(mir_event_get_window_output_event(ev));
         break;
     case mir_event_type_resize:
         /*
@@ -182,7 +182,7 @@
                    mir_resize_event_get_height(resize));
         }
         break;
-    case mir_event_type_close_surface:
+    case mir_event_type_close_window:
         printf("Received close event from server.\n");
         running = 0;
         break;
 
=== modified file 'examples/fingerpaint.c'
--- examples/fingerpaint.c	2017-01-09 06:48:47 +0000
+++ examples/fingerpaint.c	2017-01-10 20:52:04 +0000
@@ -301,7 +301,7 @@
             changed = true;
         }
     }
-    else if (event_type == mir_event_type_close_surface)
+    else if (event_type == mir_event_type_close_window)
     {
         static int closing = 0;
 
 
=== modified file 'examples/server_example_basic_window_manager.cpp'
--- examples/server_example_basic_window_manager.cpp	2016-07-18 07:38:38 +0000
+++ examples/server_example_basic_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -139,13 +139,13 @@
 int me::BasicWindowManager::set_surface_attribute(
     std::shared_ptr<scene::Session> const& /*session*/,
     std::shared_ptr<scene::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
     switch (attrib)
     {
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
     {
         auto const state = policy->handle_set_state(surface, MirSurfaceState(value));
         return surface->configure(attrib, state);
 
=== modified file 'examples/server_example_basic_window_manager.h'
--- examples/server_example_basic_window_manager.h	2016-07-18 07:38:38 +0000
+++ examples/server_example_basic_window_manager.h	2017-01-10 20:52:04 +0000
@@ -177,7 +177,7 @@
     int set_surface_attribute(
         std::shared_ptr<scene::Session> const& /*session*/,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
 
=== modified file 'examples/server_example_canonical_window_manager.cpp'
--- examples/server_example_canonical_window_manager.cpp	2016-12-09 02:54:31 +0000
+++ examples/server_example_canonical_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -100,7 +100,7 @@
 -> ms::SurfaceCreationParameters
 {
     auto parameters = request_parameters;
-    auto surf_type = parameters.type.is_set() ? parameters.type.value() : mir_surface_type_normal;
+    auto surf_type = parameters.type.is_set() ? parameters.type.value() : mir_window_type_normal;
     bool const needs_titlebar = SurfaceInfo::needs_titlebar(surf_type);
 
     if (needs_titlebar)
@@ -260,7 +260,7 @@
         .of_pixel_format(format)
         .of_buffer_usage(mir::graphics::BufferUsage::software)
         .of_position(titlebar_position_for_window(surface->top_left()))
-        .of_type(mir_surface_type_gloss)
+        .of_type(mir_window_type_gloss)
         .with_buffer_stream(stream_id);
     auto id = build(session, params);
     auto titlebar = session->surface(id);
@@ -342,7 +342,7 @@
                 throw std::runtime_error("Target surface type requires parent");
         }
 
-        surface->configure(mir_surface_attrib_type, new_type);
+        surface->configure(mir_window_attrib_type, new_type);
     }
 
     #define COPY_IF_SET(field)\
@@ -414,7 +414,7 @@
     if (modifications.state.is_set())
     {
         auto const state = handle_set_state(surface, modifications.state.value());
-        surface->configure(mir_surface_attrib_state, state);
+        surface->configure(mir_window_attrib_state, state);
     }
 
     if (modifications.confine_pointer.is_set())
@@ -823,7 +823,7 @@
             state = mir_surface_state_restored;
 
         auto const value = handle_set_state(surface, MirSurfaceState(state));
-        surface->configure(mir_surface_attrib_state, value);
+        surface->configure(mir_window_attrib_state, value);
     }
 }
 
 
=== modified file 'examples/server_example_window_management_info.cpp'
--- examples/server_example_window_management_info.cpp	2016-11-04 17:12:59 +0000
+++ examples/server_example_window_management_info.cpp	2017-01-10 20:52:04 +0000
@@ -59,17 +59,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;
@@ -80,10 +80,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:
@@ -91,19 +91,19 @@
     }
 }
 
-bool me::SurfaceInfo::can_morph_to(MirSurfaceType new_type) const
+bool me::SurfaceInfo::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:
@@ -111,14 +111,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_popover:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -137,8 +137,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:
@@ -356,15 +356,15 @@
     requested_size = new_size;
 }
 
-bool me::SurfaceInfo::needs_titlebar(MirSurfaceType type)
+bool me::SurfaceInfo::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:
 
=== modified file 'examples/server_example_window_management_info.h'
--- examples/server_example_window_management_info.h	2016-11-04 17:12:59 +0000
+++ examples/server_example_window_management_info.h	2017-01-10 20:52:04 +0000
@@ -39,7 +39,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;
 
@@ -47,7 +47,7 @@
 
     bool is_visible() const;
 
-    static bool needs_titlebar(MirSurfaceType type);
+    static bool needs_titlebar(MirWindowType type);
 
     void constrain_resize(
         std::shared_ptr <scene::Surface> const& surface,
@@ -57,7 +57,7 @@
         const bool top_resize,
         geometry::Rectangle const& bounds) const;
 
-    MirSurfaceType type;
+    MirWindowType type;
     MirSurfaceState state;
     geometry::Rectangle restore_rect;
     std::weak_ptr <scene::Session> session;
 
=== modified file 'examples/target.c'
--- examples/target.c	2017-01-09 06:48:47 +0000
+++ examples/target.c	2017-01-10 20:52:04 +0000
@@ -199,7 +199,7 @@
     case mir_event_type_resize:
         state->resized = true;
         break;
-    case mir_event_type_close_surface:
+    case mir_event_type_close_window:
         state->running = false;
         break;
     default:
 
=== modified file 'include/client/mir/event_printer.h'
--- include/client/mir/event_printer.h	2016-10-31 02:37:31 +0000
+++ include/client/mir/event_printer.h	2017-01-10 20:52:04 +0000
@@ -35,20 +35,24 @@
 std::ostream& operator<<(std::ostream& out, MirOrientation orientation);
 
 std::ostream& operator<<(std::ostream& out, MirSurfaceAttrib attribute);
+/* __attribute__ ((deprecated("use << with MirWindowAttribute instead")); */
+std::ostream& operator<<(std::ostream& out, MirWindowAttrib attribute);
 std::ostream& operator<<(std::ostream& out, MirSurfaceFocusState state);
 std::ostream& operator<<(std::ostream& out, MirSurfaceVisibility state);
 std::ostream& operator<<(std::ostream& out, MirSurfaceType type);
+/* __attribute__ ((deprecated("use << with MirWindowType instead")); */
+std::ostream& operator<<(std::ostream& out, MirWindowType type);
 std::ostream& operator<<(std::ostream& out, MirSurfaceState state);
 
 std::ostream& operator<<(std::ostream& out, MirPromptSessionEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirResizeEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirOrientationEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirInputEvent const& event);
-std::ostream& operator<<(std::ostream& out, MirCloseSurfaceEvent const& event);
+std::ostream& operator<<(std::ostream& out, MirCloseWindowEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirKeymapEvent const& event);
-std::ostream& operator<<(std::ostream& out, MirSurfaceEvent const& event);
+std::ostream& operator<<(std::ostream& out, MirWindowEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirInputDeviceStateEvent const& event);
-std::ostream& operator<<(std::ostream& out, MirSurfacePlacementEvent const& event);
+std::ostream& operator<<(std::ostream& out, MirWindowPlacementEvent const& event);
 std::ostream& operator<<(std::ostream& out, MirEvent const& event);
 
 }
 
=== modified file 'include/client/mir/events/event_builders.h'
--- include/client/mir/events/event_builders.h	2016-11-11 07:56:09 +0000
+++ include/client/mir/events/event_builders.h	2017-01-10 20:52:04 +0000
@@ -48,6 +48,9 @@
 EventUPtr make_event(frontend::SurfaceId const& surface_id, geometry::Size const& size);
 // Surface configure event
 EventUPtr make_event(frontend::SurfaceId const& surface_id, MirSurfaceAttrib attribute, int value);
+/* __attribute__ ((deprecated("use make_event with MirWindowAttribute instead")); */
+// Window configure event
+EventUPtr make_event(frontend::SurfaceId const& surface_id, MirWindowAttrib attribute, int value);
 // Close surface event
 EventUPtr make_event(frontend::SurfaceId const& surface_id);
 // Keymap event
 
=== modified file 'include/client/mir_toolkit/events/event.h'
--- include/client/mir_toolkit/events/event.h	2016-11-11 07:56:09 +0000
+++ include/client/mir_toolkit/events/event.h	2017-01-10 20:52:04 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014-2016 Canonical Ltd.
+ * Copyright © 2014-2017 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU Lesser General Public License version 3,
@@ -31,36 +31,47 @@
 extern "C" {
 #endif
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 typedef enum
 {
     mir_event_type_key,
     mir_event_type_motion,
-    mir_event_type_surface,
+    mir_event_type_surface, /* __attribute__ ((deprecated("use mir_event_type_window instead"))), */
+    mir_event_type_window = mir_event_type_surface,
     mir_event_type_resize,
     mir_event_type_prompt_session_state_change,
     mir_event_type_orientation,
-    mir_event_type_close_surface,
+    mir_event_type_close_surface, /*__attribute__ ((deprecated("use mir_event_type_close_window instead"))), */
+    mir_event_type_close_window = mir_event_type_close_surface,
     /* Type for new style input event will be returned from mir_event_get_type
        when old style event type was mir_event_type_key or mir_event_type_motion */
     mir_event_type_input,
     mir_event_type_keymap,
     mir_event_type_input_configuration,
-    mir_event_type_surface_output,
+    mir_event_type_surface_output, /* __attribute__ ((deprecated("use mir_event_type_window_output instead"))), */
+    mir_event_type_window_output = mir_event_type_surface_output,
     mir_event_type_input_device_state,
-    mir_event_type_surface_placement,
+    mir_event_type_surface_placement, /*__attribute__ ((deprecated("use mir_event_type_window_placement instead"))), */
+    mir_event_type_window_placement = mir_event_type_surface_placement,
 } MirEventType;
+#pragma GCC diagnostic pop
 
-typedef struct MirSurfaceEvent MirSurfaceEvent;
+typedef struct MirSurfaceEvent MirSurfaceEvent; /* __attribute__ ((deprecated("use MirWindowEvent instead"))); */
+typedef struct MirSurfaceEvent MirWindowEvent;
 typedef struct MirResizeEvent MirResizeEvent;
 typedef struct MirPromptSessionEvent MirPromptSessionEvent;
 typedef struct MirOrientationEvent MirOrientationEvent;
-typedef struct MirCloseSurfaceEvent MirCloseSurfaceEvent;
+typedef struct MirCloseSurfaceEvent MirCloseSurfaceEvent; /* __attribute__ ((deprecated("use MirCloseWindowEvent instead"))); */
+typedef struct MirCloseSurfaceEvent MirCloseWindowEvent;
 typedef struct MirInputEvent MirInputEvent;
 typedef struct MirKeymapEvent MirKeymapEvent;
 typedef struct MirInputConfigurationEvent MirInputConfigurationEvent;
-typedef struct MirSurfaceOutputEvent MirSurfaceOutputEvent;
+typedef struct MirSurfaceOutputEvent MirSurfaceOutputEvent; /* __attribute__ ((deprecated("use MirWindowOutputEvent instead"))); */
+typedef struct MirSurfaceOutputEvent MirWindowOutputEvent;
 typedef struct MirInputDeviceStateEvent MirInputDeviceStateEvent;
-typedef struct MirSurfacePlacementEvent MirSurfacePlacementEvent;
+typedef struct MirSurfacePlacementEvent MirSurfacePlacementEvent; /* __attribute__ ((deprecated("use MirWindowPlacementEvent instead"))); */
+typedef struct MirSurfacePlacementEvent MirWindowPlacementEvent;
 
 typedef struct MirCookie MirCookie;
 
@@ -74,11 +85,13 @@
 #include "mir_toolkit/events/input/input_event.h"
 #include "mir_toolkit/events/resize_event.h"
 #include "mir_toolkit/events/surface_event.h"
+#include "mir_toolkit/events/window_event.h"
 #include "mir_toolkit/events/orientation_event.h"
 #include "mir_toolkit/events/prompt_session_event.h"
 #include "mir_toolkit/events/keymap_event.h"
 #include "mir_toolkit/events/input_configuration_event.h"
 #include "mir_toolkit/events/surface_output_event.h"
+#include "mir_toolkit/events/window_output_event.h"
 #include "mir_toolkit/events/input_device_state_event.h"
 
 #ifdef __cplusplus
@@ -118,6 +131,17 @@
  * \return           The associated MirSurfaceEvent
  */
 MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* event);
+/* __attribute__ ((deprecated("use mir_event_get_window_event instead"))); */
+
+/**
+ * Retrieve the MirWindowEvent associated with a MirEvent of
+ * type mir_event_type_window. See <mir_toolkit/events/surface_event.h>
+ * for accessors.
+ *
+ * \param [in] event The event
+ * \return           The associated MirWindowEvent
+ */
+MirWindowEvent const* mir_event_get_window_event(MirEvent const* event);
 
 /**
  * Retrieve the MirResizeEvent associated with a MirEvent of
@@ -206,6 +230,22 @@
  * \return           The associated MirSurfaceOutputEvent
  */
 MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* event);
+/* __attribute__((deprecated("use mir_event_get_window_output_event))) */
+
+/**
+ * Retrieve the MirWindowOutputEvent associated with a MirEvent of type
+ * mir_event_type_window_output. The event signifies that the properties
+ * of the output the window is displayed upon have changed.
+ *
+ * A MirWindowOutputEvent is generated either when the properties of the
+ * output the window is primarily on change (for example: by user configuration
+ * of resolution) or when the output the window is primarily on changes
+ * (for example: when a user moves the window from one monitor to another).
+ *
+ * \param [in] event The event
+ * \return           The associated MirWindowOutputEvent
+ */
+MirWindowOutputEvent const* mir_event_get_window_output_event(MirEvent const* event);
 
 /**
  * Retrieve the MirInputDeviceStateEvent associated with a MirEvent of
@@ -228,6 +268,16 @@
  */
 MirSurfacePlacementEvent const* mir_event_get_surface_placement_event(MirEvent const* event);
 
+/**
+ * Retrieve the MirWindowPlacementEvent associated with a MirEvent of
+ * type mir_event_type_window_placement. The event signifies that the
+ * the server has fulfilled a request for relative window placement.
+ *
+ * \param [in] event The event
+ * \return           The associated MirWindowPlacementEvent
+ */
+MirWindowPlacementEvent const* mir_event_get_window_placement_event(MirEvent const* event);
+
 /*
  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  * _________________________
 
=== modified file 'include/client/mir_toolkit/events/surface_event.h'
--- include/client/mir_toolkit/events/surface_event.h	2016-10-12 06:03:15 +0000
+++ include/client/mir_toolkit/events/surface_event.h	2017-01-10 20:52:04 +0000
@@ -36,6 +36,7 @@
  * \return           The associated attribute
  */
 MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* event);
+/* __attribute__ ((deprecated("use make_event with mir_window_event_get_attribute instead"))); */
 
 /**
  * Retrieve the new value of the associated attribute for a given MirSurfaceEvent
@@ -44,6 +45,7 @@
  * \return           The associated attribute value
  */
 int mir_surface_event_get_attribute_value(MirSurfaceEvent const* event);
+/* __attribute__ ((deprecated("use make_event with mir_window_event_get_attribute_value instead"))); */
 
 #ifdef __cplusplus
 }
 
=== added file 'include/client/mir_toolkit/events/window_event.h'
--- include/client/mir_toolkit/events/window_event.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/events/window_event.h	2017-01-10 20:52:04 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Brandon Schaefer <[e-mail]>
+ */
+
+#ifndef MIR_TOOLKIT_EVENTS_WINDOW_EVENT_H_
+#define MIR_TOOLKIT_EVENTS_WINDOW_EVENT_H_
+
+#include <mir_toolkit/events/event.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Retrieve the attribute index configured with a given MirWindowEvent
+ *
+ * \param [in] event The event
+ * \return           The associated attribute
+ */
+MirWindowAttrib mir_window_event_get_attribute(MirWindowEvent const* event);
+
+/**
+ * Retrieve the new value of the associated attribute for a given MirWindowEvent
+ *
+ * \param [in] event The event
+ * \return           The associated attribute value
+ */
+int mir_window_event_get_attribute_value(MirWindowEvent const* event);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif /* MIR_TOOLKIT_WINDOW_EVENT_H_ */
 
=== added file 'include/client/mir_toolkit/events/window_output_event.h'
--- include/client/mir_toolkit/events/window_output_event.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/events/window_output_event.h	2017-01-10 20:52:04 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ *
+ */
+
+#ifndef MIR_TOOLKIT_WINDOW_OUTPUT_EVENT_H_
+#define MIR_TOOLKIT_WINDOW_OUTPUT_EVENT_H_
+
+#include <mir_toolkit/events/event.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+/**
+ * Retrieve the DPI of the new output configuration of a MirWindowOutputEvent
+ *
+ * \param [in] ev   The event
+ * \return          The new DPI value for the window is primarily on.
+ */
+int mir_window_output_event_get_dpi(MirWindowOutputEvent const* ev);
+
+/**
+ * Retrieve the form factor of the new output configuration of a MirWindowOutputEvent
+ *
+ * \param [in] ev   The event
+ * \return          The new form factor of the output the window is primarily on.
+ */
+MirFormFactor mir_window_output_event_get_form_factor(MirWindowOutputEvent const* ev);
+
+/**
+ * Retrieve the suggested scaling factor of the new output configuration of a
+ * MirWindowOutputEvent.
+ *
+ * \param [in] ev   The event
+ * \return          The new scaling factor of the output the window is primarily on.
+ */
+float mir_window_output_event_get_scale(MirWindowOutputEvent const* ev);
+
+/**
+ * Retrieve the maximum refresh rate of the output(s) associated with a
+ * MirWindowOutputEvent. For variable refresh rate displays this represents
+ * the maximum refresh rate of the display to aim for, rather than a measurement
+ * of recent performance.
+ *
+ * \param [in] ev   The event
+ * \return          The refresh rate in Hz
+ */
+double mir_window_output_event_get_refresh_rate(MirWindowOutputEvent const* ev);
+
+/**
+ * Retrieve the ID of the output this window is on from a MirWindowOutputEvent
+ *
+ * \param [in] ev   The event
+ * \return          The ID of the output the window is currently considered to be on.
+ *                  (From MirDisplayOutput::output_id)
+ */
+uint32_t mir_window_output_event_get_output_id(MirWindowOutputEvent const *ev);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif //MIR_TOOLKIT_WINDOW_OUTPUT_EVENT_H_
 
=== added file 'include/client/mir_toolkit/events/window_placement.h'
--- include/client/mir_toolkit/events/window_placement.h	1970-01-01 00:00:00 +0000
+++ include/client/mir_toolkit/events/window_placement.h	2017-01-10 20:52:04 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2017 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIR_TOOLKIT_WINDOW_PLACEMENT_H_
+#define MIR_TOOLKIT_WINDOW_PLACEMENT_H_
+
+#include <mir_toolkit/client_types.h>
+
+#ifdef __cplusplus
+/**
+ * \addtogroup mir_toolkit
+ * @{
+ */
+extern "C" {
+#endif
+
+typedef struct MirSurfacePlacementEvent MirWindowPlacementEvent;
+
+/**
+ * Retrieve the relative position from a placement notification
+ *
+ * \param [in] event  The placement event
+ * \return            The position relative to the parent window
+ */
+MirRectangle mir_window_placement_get_relative_position(MirWindowPlacementEvent const* event);
+
+#ifdef __cplusplus
+}
+/**@}*/
+#endif
+
+#endif //MIR_TOOLKIT_WINDOW_PLACEMENT_H_
 
=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2017-01-09 06:48:47 +0000
+++ include/client/mir_toolkit/mir_surface.h	2017-01-10 20:52:04 +0000
@@ -208,7 +208,7 @@
  * \param [in] spec         Specification to mutate
  * \param [in] type         the target type of the window
  */
-void mir_window_spec_set_type(MirWindowSpec* spec, MirSurfaceType type);
+void mir_window_spec_set_type(MirWindowSpec* spec, MirWindowType type);
 
 /**
  * Set the requested name.
@@ -667,6 +667,13 @@
  */
 void mir_window_raise(MirWindow* window, MirCookie const* cookie);
 
+/**
+ * Get the type (purpose) of a window.
+ *   \param [in] window  The window to query
+ *   \return              The type of the window
+ */
+MirWindowType mir_window_get_type(MirWindow* window);
+
 // Functions in this pragma section are to be deprecated
 //#pragma GCC diagnostic push
 //#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -870,12 +877,8 @@
 void mir_surface_get_parameters(MirSurface *surface, MirSurfaceParameters *parameters);
 //__attribute__((deprecated("use mir_window_get_parameters() instead")));
 
-/**
- * Get the type (purpose) of a surface.
- *   \param [in] surface  The surface to query
- *   \return              The type of the surface
- */
-MirSurfaceType mir_surface_get_type(MirSurface *surface);
+MirSurfaceType mir_surface_get_type(MirSurface* surface);
+//__attribute__((deprecated("use mir_window_get_type() instead")));
 
 /**
  * Change the state of a surface.
 
=== modified file 'include/core/mir_toolkit/common.h'
--- include/core/mir_toolkit/common.h	2016-11-11 07:56:09 +0000
+++ include/core/mir_toolkit/common.h	2017-01-10 20:52:04 +0000
@@ -43,7 +43,25 @@
     mir_surface_attrib_preferred_orientation,
     /* Must be last */
     mir_surface_attribs
-} MirSurfaceAttrib;
+} MirSurfaceAttrib; /* __attribute__ ((deprecated("use MirWindowAttrib"))); */
+
+/**
+ * Attributes of a window that the client and server/shell may wish to
+ * get or set over the wire.
+ */
+typedef enum MirWindowAttrib
+{
+    /* Do not specify values...code relies on 0...N ordering. */
+    mir_window_attrib_type,
+    mir_window_attrib_state,
+    mir_window_attrib_swapinterval,
+    mir_window_attrib_focus,
+    mir_window_attrib_dpi,
+    mir_window_attrib_visibility,
+    mir_window_attrib_preferred_orientation,
+    /* Must be last */
+    mir_window_attribs
+} MirWindowAttrib;
 
 typedef enum MirSurfaceType
 {
@@ -59,7 +77,23 @@
     mir_surface_type_satellite,    /**< AKA "toolbox"/"toolbar"             */
     mir_surface_type_tip,          /**< AKA "tooltip"                       */
     mir_surface_types
-} MirSurfaceType;
+} MirSurfaceType; /* __attribute__ ((deprecated("use MirWindowType"))); */
+
+typedef enum MirWindowType
+{
+    mir_window_type_normal,       /**< AKA "regular"                       */
+    mir_window_type_utility,      /**< AKA "floating"                      */
+    mir_window_type_dialog,
+    mir_window_type_overlay,      /**< \deprecated  Use "gloss" instead.   */
+    mir_window_type_gloss = mir_window_type_overlay,
+    mir_window_type_freestyle,
+    mir_window_type_popover,      /**< \deprecated  Choose "menu" or "tip" */
+    mir_window_type_menu = mir_window_type_popover,
+    mir_window_type_inputmethod,  /**< AKA "OSK" or handwriting etc.       */
+    mir_window_type_satellite,    /**< AKA "toolbox"/"toolbar"             */
+    mir_window_type_tip,          /**< AKA "tooltip"                       */
+    mir_window_types
+} MirWindowType;
 
 typedef enum MirSurfaceState
 {
 
=== modified file 'include/server/mir/scene/null_surface_observer.h'
--- include/server/mir/scene/null_surface_observer.h	2016-10-31 02:37:31 +0000
+++ include/server/mir/scene/null_surface_observer.h	2017-01-10 20:52:04 +0000
@@ -31,7 +31,7 @@
     NullSurfaceObserver() = default;
     virtual ~NullSurfaceObserver() = default;
 
-    void attrib_changed(MirSurfaceAttrib attrib, int value) override;
+    void attrib_changed(MirWindowAttrib attrib, int value) override;
     void resized_to(geometry::Size const& size) override;
     void moved_to(geometry::Point const& top_left) override;
     void hidden_set_to(bool hide) override;
 
=== modified file 'include/server/mir/scene/surface.h'
--- include/server/mir/scene/surface.h	2016-11-11 07:56:09 +0000
+++ include/server/mir/scene/surface.h	2017-01-10 20:52:04 +0000
@@ -68,7 +68,7 @@
     virtual int buffers_ready_for_compositor(void const* compositor_id) const = 0;
 
     virtual float alpha() const = 0; //only used in examples/
-    virtual MirSurfaceType type() const = 0;
+    virtual MirWindowType type() const = 0;
     virtual MirSurfaceState state() const = 0;
     virtual void hide() = 0;
     virtual void show() = 0;
@@ -107,9 +107,9 @@
     virtual std::shared_ptr<Surface> parent() const = 0;
 
     // TODO a legacy of old interactions and needs removing
-    virtual int configure(MirSurfaceAttrib attrib, int value) = 0;
+    virtual int configure(MirWindowAttrib attrib, int value) = 0;
     // TODO a legacy of old interactions and needs removing
-    virtual int query(MirSurfaceAttrib attrib) const = 0;
+    virtual int query(MirWindowAttrib attrib) const = 0;
 
     virtual void set_keymap(MirInputDeviceId id, std::string const& model, std::string const& layout,
                             std::string const& variant, std::string const& options) = 0;
 
=== modified file 'include/server/mir/scene/surface_creation_parameters.h'
--- include/server/mir/scene/surface_creation_parameters.h	2016-10-12 06:03:15 +0000
+++ include/server/mir/scene/surface_creation_parameters.h	2017-01-10 20:52:04 +0000
@@ -58,7 +58,7 @@
 
     SurfaceCreationParameters& with_output_id(graphics::DisplayConfigurationOutputId const& output_id);
 
-    SurfaceCreationParameters& of_type(MirSurfaceType type);
+    SurfaceCreationParameters& of_type(MirWindowType type);
 
     SurfaceCreationParameters& with_state(MirSurfaceState state);
 
@@ -81,7 +81,7 @@
     graphics::DisplayConfigurationOutputId output_id;
 
     mir::optional_value<MirSurfaceState> state;
-    mir::optional_value<MirSurfaceType> type;
+    mir::optional_value<MirWindowType> type;
     mir::optional_value<MirOrientationMode> preferred_orientation;
     mir::optional_value<frontend::SurfaceId> parent_id;
     mir::optional_value<frontend::BufferStreamId> content_id;
 
=== modified file 'include/server/mir/scene/surface_observer.h'
--- include/server/mir/scene/surface_observer.h	2016-10-31 02:37:31 +0000
+++ include/server/mir/scene/surface_observer.h	2017-01-10 20:52:04 +0000
@@ -45,7 +45,7 @@
 class SurfaceObserver
 {
 public:
-    virtual void attrib_changed(MirSurfaceAttrib attrib, int value) = 0;
+    virtual void attrib_changed(MirWindowAttrib attrib, int value) = 0;
     virtual void resized_to(geometry::Size const& size) = 0;
     virtual void moved_to(geometry::Point const& top_left) = 0;
     virtual void hidden_set_to(bool hide) = 0;
 
=== modified file 'include/server/mir/shell/abstract_shell.h'
--- include/server/mir/shell/abstract_shell.h	2016-08-02 19:44:59 +0000
+++ include/server/mir/shell/abstract_shell.h	2017-01-10 20:52:04 +0000
@@ -70,12 +70,12 @@
     int set_surface_attribute(
         std::shared_ptr<scene::Session> const& session,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     int get_surface_attribute(
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib) override;
+        MirWindowAttrib attrib) override;
 
     void raise_surface(
         std::shared_ptr<scene::Session> const& session,
 
=== modified file 'include/server/mir/shell/shell.h'
--- include/server/mir/shell/shell.h	2016-01-29 08:18:22 +0000
+++ include/server/mir/shell/shell.h	2017-01-10 20:52:04 +0000
@@ -88,12 +88,12 @@
     virtual int set_surface_attribute(
         std::shared_ptr<scene::Session> const& session,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) = 0;
 
     virtual int get_surface_attribute(
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib) = 0;
+        MirWindowAttrib attrib) = 0;
 
     virtual void raise_surface(
         std::shared_ptr<scene::Session> const& session,
 
=== modified file 'include/server/mir/shell/shell_report.h'
--- include/server/mir/shell/shell_report.h	2016-09-08 02:58:56 +0000
+++ include/server/mir/shell/shell_report.h	2017-01-10 20:52:04 +0000
@@ -54,7 +54,7 @@
 
     virtual void update_surface(
         scene::Session const& session, scene::Surface const& surface,
-        MirSurfaceAttrib attrib, int value) = 0;
+        MirWindowAttrib attrib, int value) = 0;
 
     virtual void destroying_surface(
         scene::Session const& session, frontend::SurfaceId surface) = 0;
 
=== modified file 'include/server/mir/shell/shell_wrapper.h'
--- include/server/mir/shell/shell_wrapper.h	2016-01-29 08:18:22 +0000
+++ include/server/mir/shell/shell_wrapper.h	2017-01-10 20:52:04 +0000
@@ -73,12 +73,12 @@
     int set_surface_attribute(
         std::shared_ptr<scene::Session> const& session,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     int get_surface_attribute(
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib) override;
+        MirWindowAttrib attrib) override;
 
     void raise_surface(
         std::shared_ptr<scene::Session> const& session,
 
=== modified file 'include/server/mir/shell/surface_specification.h'
--- include/server/mir/shell/surface_specification.h	2016-12-09 02:54:31 +0000
+++ include/server/mir/shell/surface_specification.h	2017-01-10 20:52:04 +0000
@@ -64,7 +64,7 @@
     optional_value<graphics::BufferUsage> buffer_usage;
     optional_value<std::string> name;
     optional_value<graphics::DisplayConfigurationOutputId> output_id;
-    optional_value<MirSurfaceType> type;
+    optional_value<MirWindowType> type;
     optional_value<MirSurfaceState> state;
     optional_value<MirOrientationMode> preferred_orientation;
     optional_value<frontend::SurfaceId> parent_id;
 
=== modified file 'include/server/mir/shell/system_compositor_window_manager.h'
--- include/server/mir/shell/system_compositor_window_manager.h	2016-01-29 08:18:22 +0000
+++ include/server/mir/shell/system_compositor_window_manager.h	2017-01-10 20:52:04 +0000
@@ -98,7 +98,7 @@
     int set_surface_attribute(
         std::shared_ptr<scene::Session> const& session,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     using OutputMap = std::map<std::weak_ptr<scene::Surface>, graphics::DisplayConfigurationOutputId, std::owner_less<std::weak_ptr<scene::Surface>>>;
 
=== modified file 'include/server/mir/shell/window_manager.h'
--- include/server/mir/shell/window_manager.h	2016-01-29 08:18:22 +0000
+++ include/server/mir/shell/window_manager.h	2017-01-10 20:52:04 +0000
@@ -68,7 +68,7 @@
     virtual int set_surface_attribute(
         std::shared_ptr<scene::Session> const& session,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) = 0;
 
     virtual void handle_raise_surface(
 
=== modified file 'include/test/mir/test/doubles/mock_window_manager.h'
--- include/test/mir/test/doubles/mock_window_manager.h	2016-01-29 08:18:22 +0000
+++ include/test/mir/test/doubles/mock_window_manager.h	2017-01-10 20:52:04 +0000
@@ -62,7 +62,7 @@
     MOCK_METHOD4(set_surface_attribute,
         int(std::shared_ptr<scene::Session> const& session,
             std::shared_ptr<scene::Surface> const& surface,
-            MirSurfaceAttrib attrib,
+            MirWindowAttrib attrib,
             int value));
 
     static frontend::SurfaceId add_surface_default(
 
=== modified file 'include/test/mir/test/doubles/stub_surface.h'
--- include/test/mir/test/doubles/stub_surface.h	2016-10-31 02:37:31 +0000
+++ include/test/mir/test/doubles/stub_surface.h	2017-01-10 20:52:04 +0000
@@ -54,10 +54,10 @@
     bool visible() const override;
     graphics::RenderableList generate_renderables(compositor::CompositorID id) const override;
     int buffers_ready_for_compositor(void const* compositor_id) const override;
-    MirSurfaceType type() const override;
+    MirWindowType type() const override;
     MirSurfaceState state() const override;
-    int configure(MirSurfaceAttrib attrib, int value) override;
-    int query(MirSurfaceAttrib attrib) const override;
+    int configure(MirWindowAttrib attrib, int value) override;
+    int query(MirWindowAttrib attrib) const override;
     void hide() override;
     void show() override;
     void set_cursor_image(std::shared_ptr<graphics::CursorImage> const& image) override;
 
=== modified file 'include/test/mir/test/event_matchers.h'
--- include/test/mir/test/event_matchers.h	2017-01-06 03:31:04 +0000
+++ include/test/mir/test/event_matchers.h	2017-01-10 20:52:04 +0000
@@ -488,15 +488,16 @@
     return true;
 }
 
-MATCHER_P2(SurfaceEvent, attrib, value, "")
+MATCHER_P2(WindowEvent, attrib, value, "")
 {
     auto as_address = to_address(arg);
-    if (mir_event_get_type(as_address) != mir_event_type_surface)
-        return false;
-    auto surface_ev = mir_event_get_surface_event(as_address);
-    if (mir_surface_event_get_attribute(surface_ev) != attrib)
-        return false;
-    if (mir_surface_event_get_attribute_value(surface_ev) != value)
+    if (mir_event_get_type(as_address) != mir_event_type_window)
+        return false;
+    auto surface_ev = mir_event_get_window_event(as_address);
+    auto window_attrib = mir_window_event_get_attribute(surface_ev);
+    if (window_attrib != attrib)
+        return false;
+    if (mir_window_event_get_attribute_value(surface_ev) != value)
         return false;
     return true;
 }
 
=== modified file 'src/client/buffer_stream.cpp'
--- src/client/buffer_stream.cpp	2017-01-09 06:48:47 +0000
+++ src/client/buffer_stream.cpp	2017-01-10 20:52:04 +0000
@@ -411,12 +411,12 @@
     swap_buffers([](){})->wait_for_all();
 }
 
-void mcl::BufferStream::request_and_wait_for_configure(MirSurfaceAttrib attrib, int interval)
+void mcl::BufferStream::request_and_wait_for_configure(MirWindowAttrib attrib, int interval)
 {
-    if (attrib != mir_surface_attrib_swapinterval)
+    if (attrib != mir_window_attrib_swapinterval)
     {
         BOOST_THROW_EXCEPTION(std::logic_error("Attempt to configure surface attribute " + std::to_string(attrib) +
-        " on BufferStream but only mir_surface_attrib_swapinterval is supported")); 
+        " on BufferStream but only mir_window_attrib_swapinterval is supported")); 
     }
     mir_wait_for(set_swap_interval(interval));
 }
 
=== modified file 'src/client/buffer_stream.h'
--- src/client/buffer_stream.h	2017-01-09 06:48:47 +0000
+++ src/client/buffer_stream.h	2017-01-10 20:52:04 +0000
@@ -106,7 +106,7 @@
     MirWindowParameters get_parameters() const override;
     void swap_buffers_sync() override;
 
-    void request_and_wait_for_configure(MirSurfaceAttrib attrib, int) override;
+    void request_and_wait_for_configure(MirWindowAttrib attrib, int) override;
 
     MirNativeBuffer* get_current_buffer_package() override;
 
 
=== modified file 'src/client/event.cpp'
--- src/client/event.cpp	2016-11-11 07:56:09 +0000
+++ src/client/event.cpp	2017-01-10 20:52:04 +0000
@@ -33,6 +33,7 @@
 #include "mir_toolkit/events/orientation_event.h"
 #include "mir_toolkit/events/input_device_state_event.h"
 #include "mir_toolkit/events/surface_placement.h"
+#include "mir_toolkit/events/window_placement.h"
 
 #include <cstdlib>
 #include <cstring>
@@ -71,20 +72,22 @@
         return "mir_event_type_key";
     case mir_event_type_motion:
         return "mir_event_type_motion";
-    case mir_event_type_surface:
-        return "mir_event_type_surface";
+    case mir_event_type_window:
+        return "mir_event_type_window";
     case mir_event_type_resize:
         return "mir_event_type_resize";
     case mir_event_type_prompt_session_state_change:
         return "mir_event_type_prompt_session_state_change";
     case mir_event_type_orientation:
         return "mir_event_type_orientation";
-    case mir_event_type_close_surface:
-        return "mir_event_type_close_surface";
+    case mir_event_type_close_window:
+        return "mir_event_type_close_window";
     case mir_event_type_input:
         return "mir_event_type_input";
     case mir_event_type_input_device_state:
         return "mir_event_type_input_device_state";
+    case mir_event_type_window_output:
+        return "mir_event_type_window_output";
     default:
         abort();
     }
@@ -111,7 +114,14 @@
 
 MirSurfaceEvent const* mir_event_get_surface_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface);
+    expect_event_type(ev, mir_event_type_window);
+
+    return ev->to_surface();
+})
+
+MirWindowEvent const* mir_event_get_window_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window);
 
     return ev->to_surface();
 })
@@ -139,7 +149,7 @@
 
 MirCloseSurfaceEvent const* mir_event_get_close_surface_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_close_surface);
+    expect_event_type(ev, mir_event_type_close_window);
 
     return ev->to_close_surface();
 })
@@ -163,7 +173,14 @@
 
 MirSurfaceOutputEvent const* mir_event_get_surface_output_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
+
+    return ev->to_surface_output();
+})
+
+MirWindowOutputEvent const* mir_event_get_window_output_event(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
 
     return ev->to_surface_output();
 })
@@ -179,14 +196,30 @@
 
 MirSurfaceAttrib mir_surface_event_get_attribute(MirSurfaceEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface);
+    expect_event_type(ev, mir_event_type_window);
+
+    return static_cast<MirSurfaceAttrib>(ev->attrib());
+})
+
+int mir_surface_event_get_attribute_value(MirSurfaceEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window);
+
+    return ev->value();
+})
+
+/* Window event accessors */
+
+MirWindowAttrib mir_window_event_get_attribute(MirWindowEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window);
 
     return ev->attrib();
 })
 
-int mir_surface_event_get_attribute_value(MirSurfaceEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+int mir_window_event_get_attribute_value(MirWindowEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface);
+    expect_event_type(ev, mir_event_type_window);
 
     return ev->value();
 })
@@ -264,31 +297,63 @@
 
 int mir_surface_output_event_get_dpi(MirSurfaceOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
     return ev->dpi();
 })
 
 MirFormFactor mir_surface_output_event_get_form_factor(MirSurfaceOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
     return ev->form_factor();
 })
 
 float mir_surface_output_event_get_scale(MirSurfaceOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
     return ev->scale();
 })
 
 double mir_surface_output_event_get_refresh_rate(MirSurfaceOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
     return ev->refresh_rate();
 })
 
 uint32_t mir_surface_output_event_get_output_id(MirSurfaceOutputEvent const *ev) MIR_HANDLE_EVENT_EXCEPTION(
 {
-    expect_event_type(ev, mir_event_type_surface_output);
+    expect_event_type(ev, mir_event_type_window_output);
+    return ev->output_id();
+})
+
+/* Window output event accessors */
+
+int mir_window_output_event_get_dpi(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
+    return ev->dpi();
+})
+
+MirFormFactor mir_window_output_event_get_form_factor(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
+    return ev->form_factor();
+})
+
+float mir_window_output_event_get_scale(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
+    return ev->scale();
+})
+
+double mir_window_output_event_get_refresh_rate(MirWindowOutputEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
+    return ev->refresh_rate();
+})
+
+uint32_t mir_window_output_event_get_output_id(MirWindowOutputEvent const *ev) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    expect_event_type(ev, mir_event_type_window_output);
     return ev->output_id();
 })
 
@@ -362,6 +427,16 @@
     return event->placement();
 })
 
+MirWindowPlacementEvent const* mir_event_get_window_placement_event(MirEvent const* event) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    return event->to_surface_placement();
+})
+
+MirRectangle mir_window_placement_get_relative_position(MirWindowPlacementEvent const* event) MIR_HANDLE_EVENT_EXCEPTION(
+{
+    return event->placement();
+})
+
 // TODO: Until we opaquify the MirEvent structure and add
 // a ref count ref is implemented as copy.
 MirEvent const* mir_event_ref(MirEvent const* ev) MIR_HANDLE_EVENT_EXCEPTION(
 
=== modified file 'src/client/event_printer.cpp'
--- src/client/event_printer.cpp	2016-12-09 02:54:31 +0000
+++ src/client/event_printer.cpp	2017-01-10 20:52:04 +0000
@@ -146,6 +146,22 @@
     }
 }
 
+std::ostream& mir::operator<<(std::ostream& out, MirWindowAttrib attribute)
+{
+    switch (attribute)
+    {
+    PRINT(mir_window_attrib,type);
+    PRINT(mir_window_attrib,dpi);
+    PRINT(mir_window_attrib,focus);
+    PRINT(mir_window_attrib,state);
+    PRINT(mir_window_attrib,visibility);
+    PRINT(mir_window_attrib,swapinterval);
+    PRINT(mir_window_attrib,preferred_orientation);
+    default:
+        return out << static_cast<int>(attribute) << "<INVALID>";
+    }
+}
+
 std::ostream& mir::operator<<(std::ostream& out, MirSurfaceFocusState state)
 {
     switch (state)
@@ -186,6 +202,24 @@
     }
 }
 
+std::ostream& mir::operator<<(std::ostream& out, MirWindowType type)
+{
+    switch (type)
+    {
+    PRINT(mir_window_type,normal);
+    PRINT(mir_window_type,utility);
+    PRINT(mir_window_type,dialog);
+    PRINT(mir_window_type,gloss);
+    PRINT(mir_window_type,freestyle);
+    PRINT(mir_window_type,menu);
+    PRINT(mir_window_type,inputmethod);
+    PRINT(mir_window_type,satellite);
+    PRINT(mir_window_type,tip);
+    default:
+        return out << static_cast<int>(type) << "<INVALID>";
+    }
+}
+
 std::ostream& mir::operator<<(std::ostream& out, MirSurfaceState state)
 {
     switch (state)
@@ -283,37 +317,37 @@
     return out << "keymap_event(blob, device_id=" << mir_keymap_event_get_device_id(&event) << ")";
 }
 
-std::ostream& mir::operator<<(std::ostream& out, MirCloseSurfaceEvent const&)
+std::ostream& mir::operator<<(std::ostream& out, MirCloseWindowEvent const&)
 {
     return out << "close_surface_event()";
 }
 
-std::ostream& mir::operator<<(std::ostream& out, MirSurfaceEvent const& event)
+std::ostream& mir::operator<<(std::ostream& out, MirWindowEvent const& event)
 {
-    out << "surface_event("
-        << mir_surface_event_get_attribute(&event)<< '=';
-    auto value = mir_surface_event_get_attribute_value(&event);
-    switch (mir_surface_event_get_attribute(&event))
+    out << "window_event("
+        << mir_window_event_get_attribute(&event)<< '=';
+    auto value = mir_window_event_get_attribute_value(&event);
+    switch (mir_window_event_get_attribute(&event))
     {
-    case mir_surface_attrib_type:
-        out << static_cast<MirSurfaceType>(value);
+    case mir_window_attrib_type:
+        out << static_cast<MirWindowType>(value);
         break;
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
         out << static_cast<MirSurfaceState>(value);
         break;
-    case mir_surface_attrib_swapinterval:
+    case mir_window_attrib_swapinterval:
         out << value;
         break;
-    case mir_surface_attrib_focus:
+    case mir_window_attrib_focus:
         out << static_cast<MirSurfaceFocusState>(value);
         break;
-    case mir_surface_attrib_dpi:
+    case mir_window_attrib_dpi:
         out << value;
         break;
-    case mir_surface_attrib_visibility:
+    case mir_window_attrib_visibility:
         out << static_cast<MirSurfaceVisibility>(value);
         break;
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         out << value;
         break;
     default:
@@ -323,7 +357,7 @@
     return out << ')';
 }
 
-std::ostream& mir::operator<<(std::ostream& out, MirSurfacePlacementEvent const& event)
+std::ostream& mir::operator<<(std::ostream& out, MirWindowPlacementEvent const& event)
 {
     auto const& placement = event.placement();
     return out << "surface_placement_event({"
@@ -366,16 +400,15 @@
 
 std::ostream& mir::operator<<(std::ostream& out, MirEvent const& event)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     auto type = mir_event_get_type(&event);
     switch (type)
     {
         PRINT_EVENT(surface);
         PRINT_EVENT(resize);
         PRINT_EVENT(orientation);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
         PRINT_EVENT(close_surface);
-#pragma GCC diagnostic pop
         PRINT_EVENT(input);
         PRINT_EVENT(input_device_state);
         PRINT_EVENT(keymap);
@@ -385,5 +418,6 @@
     default:
         return out << static_cast<int>(type) << "<INVALID>";
     }
+#pragma GCC diagnostic pop
 }
 
 
=== modified file 'src/client/events/event_builders.cpp'
--- src/client/events/event_builders.cpp	2016-11-11 06:59:42 +0000
+++ src/client/events/event_builders.cpp	2017-01-10 20:52:04 +0000
@@ -90,6 +90,17 @@
     auto e = new_event<MirSurfaceEvent>();
 
     e->set_id(surface_id.as_value());
+    e->set_attrib(static_cast<MirWindowAttrib>(attribute));
+    e->set_value(value);
+
+    return make_uptr_event(e);
+}
+
+mir::EventUPtr mev::make_event(mf::SurfaceId const& surface_id, MirWindowAttrib attribute, int value)
+{
+    auto e = new_event<MirSurfaceEvent>();
+
+    e->set_id(surface_id.as_value());
     e->set_attrib(attribute);
     e->set_value(value);
 
 
=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2017-01-09 20:01:45 +0000
+++ src/client/mir_surface.cpp	2017-01-10 20:52:04 +0000
@@ -69,7 +69,7 @@
       pixel_format{params.pixel_format},
       buffer_usage{params.buffer_usage}
 {
-    type = mir_surface_type_normal;
+    type = mir_window_type_normal;
     if (params.output_id != mir_display_output_id_invalid)
     {
         output_id = params.output_id;
@@ -279,13 +279,13 @@
     return &configure_cursor_wait_handle;
 }
 
-MirWaitHandle* MirSurface::configure(MirSurfaceAttrib at, int value)
+MirWaitHandle* MirSurface::configure(MirWindowAttrib at, int value)
 {
     // TODO: This is obviously strange. It should be
     // possible to eliminate it in the second phase of buffer
     // stream where the existing MirSurface swap interval functions
     // may be deprecated in terms of mir_buffer_stream_ alternatives
-    if ((at == mir_surface_attrib_swapinterval) && default_stream)
+    if ((at == mir_window_attrib_swapinterval) && default_stream)
     {
         default_stream->set_swap_interval(value);
         return &configure_wait_handle;
@@ -360,11 +360,11 @@
 
         switch (a)
         {
-        case mir_surface_attrib_type:
-        case mir_surface_attrib_state:
-        case mir_surface_attrib_focus:
-        case mir_surface_attrib_dpi:
-        case mir_surface_attrib_preferred_orientation:
+        case mir_window_attrib_type:
+        case mir_window_attrib_state:
+        case mir_window_attrib_focus:
+        case mir_window_attrib_dpi:
+        case mir_window_attrib_preferred_orientation:
             if (configure_result->has_ivalue())
                 attrib_cache[a] = configure_result->ivalue();
             else
@@ -385,11 +385,11 @@
 }
 
 
-int MirSurface::attrib(MirSurfaceAttrib at) const
+int MirSurface::attrib(MirWindowAttrib at) const
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
 
-    if (at == mir_surface_attrib_swapinterval)
+    if (at == mir_window_attrib_swapinterval)
     {
         if (default_stream)
             return default_stream->swap_interval();
@@ -430,12 +430,12 @@
 
     switch (mir_event_get_type(&e))
     {
-    case mir_event_type_surface:
+    case mir_event_type_window:
     {
-        auto sev = mir_event_get_surface_event(&e);
-        auto a = mir_surface_event_get_attribute(sev);
-        if (a < mir_surface_attribs)
-            attrib_cache[a] = mir_surface_event_get_attribute_value(sev);
+        auto sev = mir_event_get_window_event(&e);
+        auto a = mir_window_event_get_attribute(sev);
+        if (a < mir_window_attribs)
+            attrib_cache[a] = mir_window_event_get_attribute_value(sev);
         break;
     }
     case mir_event_type_orientation:
@@ -470,7 +470,7 @@
     }
 }
 
-void MirSurface::request_and_wait_for_configure(MirSurfaceAttrib a, int value)
+void MirSurface::request_and_wait_for_configure(MirWindowAttrib a, int value)
 {
     configure(a, value)->wait_for_all();
 }
@@ -484,7 +484,7 @@
 
 MirWaitHandle* MirSurface::set_preferred_orientation(MirOrientationMode mode)
 {
-    return configure(mir_surface_attrib_preferred_orientation, mode);
+    return configure(mir_window_attrib_preferred_orientation, mode);
 }
 
 void MirSurface::raise_surface(MirCookie const* cookie)
 
=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2017-01-09 06:48:47 +0000
+++ src/client/mir_surface.h	2017-01-10 20:52:04 +0000
@@ -102,7 +102,7 @@
     mir::optional_value<std::string> surface_name;
     mir::optional_value<uint32_t> output_id;
 
-    mir::optional_value<MirSurfaceType> type;
+    mir::optional_value<MirWindowType> type;
     mir::optional_value<MirSurfaceState> state;
     mir::optional_value<MirOrientationMode> pref_orientation;
 
@@ -183,7 +183,7 @@
     char const * get_error_message();
     int id() const;
 
-    MirWaitHandle* configure(MirSurfaceAttrib a, int value);
+    MirWaitHandle* configure(MirWindowAttrib a, int value);
 
     // TODO: Some sort of extension mechanism so that this can be moved
     //       out into a separate class in the libmirclient-debug DSO.
@@ -191,7 +191,7 @@
                                          int* screen_x, int* screen_y);
     
     // Non-blocking
-    int attrib(MirSurfaceAttrib a) const;
+    int attrib(MirWindowAttrib a) const;
 
     MirOrientation get_orientation() const;
     MirWaitHandle* set_preferred_orientation(MirOrientationMode mode);
@@ -204,7 +204,7 @@
                            void* context);
     void handle_event(MirEvent const& e);
 
-    void request_and_wait_for_configure(MirSurfaceAttrib a, int value);
+    void request_and_wait_for_configure(MirWindowAttrib a, int value);
 
     MirBufferStream* get_buffer_stream();
 
@@ -248,7 +248,7 @@
     std::unique_ptr<mir::protobuf::SurfaceSetting> const configure_result;
 
     // Cache of latest SurfaceSettings returned from the server
-    int attrib_cache[mir_surface_attribs];
+    int attrib_cache[mir_window_attribs];
     MirOrientation orientation = mir_orientation_normal;
 
     std::function<void(MirEvent const*)> handle_event_callback;
 
=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2017-01-09 06:48:47 +0000
+++ src/client/mir_surface_api.cpp	2017-01-10 20:52:04 +0000
@@ -42,7 +42,7 @@
                               int width, int height)
 {
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_normal;
+    spec->type = mir_window_type_normal;
     return spec;
 }
 
@@ -57,7 +57,7 @@
     mir::require(rect != nullptr);
 
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_menu;
+    spec->type = mir_window_type_menu;
     spec->parent = parent;
     spec->aux_rect = *rect;
     spec->edge_attachment = edge;
@@ -74,7 +74,7 @@
     mir::require(rect != nullptr);
 
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_tip;
+    spec->type = mir_window_type_tip;
     spec->parent = parent;
     spec->aux_rect = *rect;
     spec->edge_attachment = edge;
@@ -88,7 +88,7 @@
     mir::require(mir_window_is_valid(parent));
 
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_dialog;
+    spec->type = mir_window_type_dialog;
     spec->parent = parent;
 
     return spec;
@@ -99,7 +99,7 @@
                               int width, int height)
 {
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_dialog;
+    spec->type = mir_window_type_dialog;
     return spec;
 }
 
@@ -108,7 +108,7 @@
                                     int width, int height)
 {
     auto spec = new MirWindowSpec{connection, width, height, mir_pixel_format_invalid};
-    spec->type = mir_surface_type_inputmethod;
+    spec->type = mir_window_type_inputmethod;
     return spec;
 }
 
@@ -137,7 +137,7 @@
     MIR_LOG_UNCAUGHT_EXCEPTION(ex);
 }
 
-void mir_window_spec_set_type(MirWindowSpec* spec, MirSurfaceType type)
+void mir_window_spec_set_type(MirWindowSpec* spec, MirWindowType type)
 try
 {
     mir::require(spec);
@@ -301,7 +301,7 @@
     mir::require(attachment_rect != nullptr);
 
     if (!spec->type.is_set() ||
-        spec->type.value() != mir_surface_type_inputmethod)
+        spec->type.value() != mir_window_type_inputmethod)
     {
         return false;
     }
@@ -624,6 +624,22 @@
     }
 }
 
+MirWindowType mir_window_get_type(MirWindow* window)
+{
+    MirWindowType type = mir_window_type_normal;
+
+    if (window)
+    {
+        // Only the client will ever change the type of a window so it is
+        // safe to get the type from a local cache surf->attrib().
+
+        int t = window->attrib(mir_window_attrib_type);
+        type = static_cast<MirWindowType>(t);
+    }
+
+    return type;
+}
+
 // These functions will be deprecated soon
 //#pragma GCC diagnostic push
 //#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -887,7 +903,7 @@
 
 void mir_surface_spec_set_type(MirSurfaceSpec* spec, MirSurfaceType type)
 {
-    mir_window_spec_set_type(spec, type);
+    mir_window_spec_set_type(spec, static_cast<MirWindowType>(type));
 }
 
 void mir_surface_spec_set_width_increment(MirSurfaceSpec* spec, unsigned width_inc)
@@ -976,25 +992,14 @@
 
 MirSurfaceType mir_surface_get_type(MirSurface* surf)
 {
-    MirSurfaceType type = mir_surface_type_normal;
-
-    if (surf)
-    {
-        // Only the client will ever change the type of a surface so it is
-        // safe to get the type from a local cache surf->attrib().
-
-        int t = surf->attrib(mir_surface_attrib_type);
-        type = static_cast<MirSurfaceType>(t);
-    }
-
-    return type;
+    return static_cast<MirSurfaceType>(mir_window_get_type(surf));
 }
 
 MirWaitHandle* mir_surface_set_state(MirSurface* surf, MirSurfaceState state)
 {
     try
     {
-        return surf ? surf->configure(mir_surface_attrib_state, state) : nullptr;
+        return surf ? surf->configure(mir_window_attrib_state, state) : nullptr;
     }
     catch (std::exception const& ex)
     {
@@ -1011,13 +1016,13 @@
     {
         if (surf)
         {
-            int s = surf->attrib(mir_surface_attrib_state);
+            int s = surf->attrib(mir_window_attrib_state);
 
             if (s == mir_surface_state_unknown)
             {
-                surf->configure(mir_surface_attrib_state,
+                surf->configure(mir_window_attrib_state,
                                 mir_surface_state_unknown)->wait_for_all();
-                s = surf->attrib(mir_surface_attrib_state);
+                s = surf->attrib(mir_window_attrib_state);
             }
 
             state = static_cast<MirSurfaceState>(s);
@@ -1085,7 +1090,7 @@
     {
         if (surf)
         {
-            dpi = surf->attrib(mir_surface_attrib_dpi);
+            dpi = surf->attrib(mir_window_attrib_dpi);
         }
     }
     catch (std::exception const& ex)
@@ -1104,7 +1109,7 @@
     {
         if (surf)
         {
-            state = static_cast<MirSurfaceFocusState>(surf->attrib(mir_surface_attrib_focus));
+            state = static_cast<MirSurfaceFocusState>(surf->attrib(mir_window_attrib_focus));
         }
     }
     catch (std::exception const& ex)
@@ -1123,7 +1128,7 @@
     {
         if (surf)
         {
-            state = static_cast<MirSurfaceVisibility>(surf->attrib(mir_surface_attrib_visibility));
+            state = static_cast<MirSurfaceVisibility>(surf->attrib(mir_window_attrib_visibility));
         }
     }
     catch (std::exception const& ex)
@@ -1159,7 +1164,7 @@
 
     try
     {
-        mode = static_cast<MirOrientationMode>(surf->attrib(mir_surface_attrib_preferred_orientation));
+        mode = static_cast<MirOrientationMode>(surf->attrib(mir_window_attrib_preferred_orientation));
     }
     catch (std::exception const& ex)
     {
 
=== modified file 'src/client/rpc/mir_protobuf_rpc_channel.cpp'
--- src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-01-06 05:29:00 +0000
+++ src/client/rpc/mir_protobuf_rpc_channel.cpp	2017-01-10 20:52:04 +0000
@@ -400,7 +400,7 @@
 
                     switch (e->type())
                     {
-                    case mir_event_type_surface:
+                    case mir_event_type_window:
                         surface_id = e->to_surface()->id();
                         break;
                     case mir_event_type_resize:
@@ -409,16 +409,16 @@
                     case mir_event_type_orientation:
                         surface_id = e->to_orientation()->surface_id();
                         break;
-                    case mir_event_type_close_surface:
+                    case mir_event_type_close_window:
                         surface_id = e->to_close_surface()->surface_id();
                         break;
                     case mir_event_type_keymap:
                         surface_id = e->to_keymap()->surface_id();
                         break;
-                    case mir_event_type_surface_output:
+                    case mir_event_type_window_output:
                         surface_id = e->to_surface_output()->surface_id();
                         break;
-                    case mir_event_type_surface_placement:
+                    case mir_event_type_window_placement:
                         surface_id = e->to_surface_placement()->id();
                         break;
                     default:
 
=== modified file 'src/client/screencast_stream.cpp'
--- src/client/screencast_stream.cpp	2017-01-09 06:48:47 +0000
+++ src/client/screencast_stream.cpp	2017-01-10 20:52:04 +0000
@@ -254,7 +254,7 @@
     BOOST_THROW_EXCEPTION(std::logic_error("Attempt to set cache size on screencast is invalid"));
 }
 
-void mcl::ScreencastStream::request_and_wait_for_configure(MirSurfaceAttrib, int)
+void mcl::ScreencastStream::request_and_wait_for_configure(MirWindowAttrib, int)
 {
     BOOST_THROW_EXCEPTION(std::logic_error("Attempt to set attrib on screencast is invalid"));
 }
 
=== modified file 'src/client/screencast_stream.h'
--- src/client/screencast_stream.h	2017-01-09 06:48:47 +0000
+++ src/client/screencast_stream.h	2017-01-10 20:52:04 +0000
@@ -84,7 +84,7 @@
     std::shared_ptr<MemoryRegion> secure_for_cpu_write() override;
 
     void swap_buffers_sync() override;
-    void request_and_wait_for_configure(MirSurfaceAttrib attrib, int) override;
+    void request_and_wait_for_configure(MirWindowAttrib attrib, int) override;
     MirNativeBuffer* get_current_buffer_package() override;
     MirPlatformType platform_type() override;
 
 
=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2017-01-09 06:48:47 +0000
+++ src/client/symbols.map	2017-01-10 20:52:04 +0000
@@ -550,4 +550,16 @@
     mir_window_get_parameters;
     mir_window_get_orientation;
     mir_window_raise;
+    mir_event_get_window_event;
+    mir_window_event_get_attribute;
+    mir_window_event_get_attribute_value;
+    mir_window_get_type;
+    mir_event_get_window_output_event;
+    mir_window_output_event_get_dpi;
+    mir_window_output_event_get_form_factor;
+    mir_window_output_event_get_scale;
+    mir_window_output_event_get_output_id;
+    mir_window_output_event_get_refresh_rate;
+    mir_event_get_window_placement_event;
+    mir_window_placement_get_relative_position;
 } MIR_CLIENT_0.25;
 
=== modified file 'src/common/events/event.cpp'
--- src/common/events/event.cpp	2016-11-11 07:56:09 +0000
+++ src/common/events/event.cpp	2017-01-10 20:52:04 +0000
@@ -82,7 +82,7 @@
     case mir::capnp::Event::Which::INPUT:
         return mir_event_type_input;
     case mir::capnp::Event::Which::SURFACE:
-        return mir_event_type_surface;
+        return mir_event_type_window;
     case mir::capnp::Event::Which::RESIZE:
         return mir_event_type_resize;
     case mir::capnp::Event::Which::PROMPT_SESSION:
@@ -90,7 +90,7 @@
     case mir::capnp::Event::Which::ORIENTATION:
         return mir_event_type_orientation;
     case mir::capnp::Event::Which::CLOSE_SURFACE:
-        return mir_event_type_close_surface;
+        return mir_event_type_close_window;
     case mir::capnp::Event::Which::KEYMAP:
         return mir_event_type_keymap;
 #pragma GCC diagnostic push
@@ -99,11 +99,11 @@
         return mir_event_type_input_configuration;
 #pragma GCC diagnostic pop
     case mir::capnp::Event::Which::SURFACE_OUTPUT:
-        return mir_event_type_surface_output;
+        return mir_event_type_window_output;
     case mir::capnp::Event::Which::INPUT_DEVICE:
         return mir_event_type_input_device_state;
     case mir::capnp::Event::Which::SURFACE_PLACEMENT:
-        return mir_event_type_surface_placement;
+        return mir_event_type_window_placement;
     default:
         mir::log_critical("unknown event type.");
         abort();
@@ -133,14 +133,14 @@
 }
 #pragma GCC diagnostic pop
 
-MirSurfaceEvent* MirEvent::to_surface()
+MirWindowEvent* MirEvent::to_surface()
 {
-    return static_cast<MirSurfaceEvent*>(this);
+    return static_cast<MirWindowEvent*>(this);
 }
 
-MirSurfaceEvent const* MirEvent::to_surface() const
+MirWindowEvent const* MirEvent::to_surface() const
 {
-    return static_cast<MirSurfaceEvent const*>(this);
+    return static_cast<MirWindowEvent const*>(this);
 }
 
 MirResizeEvent* MirEvent::to_resize()
 
=== modified file 'src/common/events/surface_event.cpp'
--- src/common/events/surface_event.cpp	2016-10-31 02:37:31 +0000
+++ src/common/events/surface_event.cpp	2017-01-10 20:52:04 +0000
@@ -33,12 +33,12 @@
     event.getSurface().setId(id);
 }
 
-MirSurfaceAttrib MirSurfaceEvent::attrib() const
+MirWindowAttrib MirSurfaceEvent::attrib() const
 {
-    return static_cast<MirSurfaceAttrib>(event.asReader().getSurface().getAttrib());
+    return static_cast<MirWindowAttrib>(event.asReader().getSurface().getAttrib());
 }
 
-void MirSurfaceEvent::set_attrib(MirSurfaceAttrib attrib)
+void MirSurfaceEvent::set_attrib(MirWindowAttrib attrib)
 {
     event.getSurface().setAttrib(static_cast<mir::capnp::SurfaceEvent::Attrib>(attrib));
 }
 
=== modified file 'src/include/client/mir/egl_native_surface.h'
--- src/include/client/mir/egl_native_surface.h	2017-01-09 06:48:47 +0000
+++ src/include/client/mir/egl_native_surface.h	2017-01-10 20:52:04 +0000
@@ -34,7 +34,7 @@
     virtual MirWindowParameters get_parameters() const = 0;
     virtual std::shared_ptr<ClientBuffer> get_current_buffer() = 0;
     virtual void swap_buffers_sync() = 0;
-    virtual void request_and_wait_for_configure(MirSurfaceAttrib a, int value) = 0;
+    virtual void request_and_wait_for_configure(MirWindowAttrib a, int value) = 0;
     virtual void set_buffer_cache_size(unsigned int) = 0;
 
   protected:
 
=== modified file 'src/include/common/mir/events/event.h'
--- src/include/common/mir/events/event.h	2016-11-11 06:59:42 +0000
+++ src/include/common/mir/events/event.h	2017-01-10 20:52:04 +0000
@@ -40,8 +40,8 @@
     MirInputConfigurationEvent* to_input_configuration();
     MirInputConfigurationEvent const* to_input_configuration() const;
 
-    MirSurfaceEvent* to_surface();
-    MirSurfaceEvent const* to_surface() const;
+    MirWindowEvent* to_surface();
+    MirWindowEvent const* to_surface() const;
 
     MirResizeEvent* to_resize();
     MirResizeEvent const* to_resize() const;
 
=== modified file 'src/include/common/mir/events/surface_event.h'
--- src/include/common/mir/events/surface_event.h	2016-10-31 02:37:31 +0000
+++ src/include/common/mir/events/surface_event.h	2017-01-10 20:52:04 +0000
@@ -28,8 +28,8 @@
     int id() const;
     void set_id(int id);
 
-    MirSurfaceAttrib attrib() const;
-    void set_attrib(MirSurfaceAttrib attrib);
+    MirWindowAttrib attrib() const;
+    void set_attrib(MirWindowAttrib attrib);
 
     int value() const;
     void set_value(int value);
 
=== modified file 'src/include/common/mir/events/surface_output_event.h'
--- src/include/common/mir/events/surface_output_event.h	2016-11-11 06:59:42 +0000
+++ src/include/common/mir/events/surface_output_event.h	2017-01-10 20:52:04 +0000
@@ -23,8 +23,6 @@
 
 #include "mir/events/event.h"
 
-// XXX This is a private structure so why are its members kept private?
-//     What's the point in having all the getters and setters?
 struct MirSurfaceOutputEvent : MirEvent
 {
     MirSurfaceOutputEvent();
 
=== modified file 'src/include/server/mir/frontend/shell.h'
--- src/include/server/mir/frontend/shell.h	2016-01-29 08:18:22 +0000
+++ src/include/server/mir/frontend/shell.h	2017-01-10 20:52:04 +0000
@@ -74,13 +74,13 @@
     virtual int set_surface_attribute(
         std::shared_ptr<Session> const& session,
         SurfaceId surface_id,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) = 0;
 
     virtual int get_surface_attribute(
         std::shared_ptr<Session> const& session,
         SurfaceId surface_id,
-        MirSurfaceAttrib attrib) = 0;
+        MirWindowAttrib attrib) = 0;
 
     virtual void raise_surface(
         std::shared_ptr<Session> const& session,
 
=== modified file 'src/include/server/mir/scene/surface_event_source.h'
--- src/include/server/mir/scene/surface_event_source.h	2016-10-31 02:37:31 +0000
+++ src/include/server/mir/scene/surface_event_source.h	2017-01-10 20:52:04 +0000
@@ -42,7 +42,7 @@
         OutputPropertiesCache const& outputs,
         std::shared_ptr<frontend::EventSink> const& event_sink);
 
-    void attrib_changed(MirSurfaceAttrib attrib, int value) override;
+    void attrib_changed(MirWindowAttrib attrib, int value) override;
     void resized_to(geometry::Size const& size) override;
     void moved_to(geometry::Point const& top_left) override;
     void orientation_set_to(MirOrientation orientation) override;
 
=== modified file 'src/include/server/mir/scene/surface_observers.h'
--- src/include/server/mir/scene/surface_observers.h	2016-10-31 02:37:31 +0000
+++ src/include/server/mir/scene/surface_observers.h	2017-01-10 20:52:04 +0000
@@ -34,7 +34,7 @@
     using BasicObservers<SurfaceObserver>::remove;
     using BasicObservers<SurfaceObserver>::for_each;
 
-    void attrib_changed(MirSurfaceAttrib attrib, int value) override;
+    void attrib_changed(MirWindowAttrib attrib, int value) override;
     void resized_to(geometry::Size const& size) override;
     void moved_to(geometry::Point const& top_left) override;
     void hidden_set_to(bool hide) override;
 
=== modified file 'src/include/server/mir/shell/basic_window_manager.h'
--- src/include/server/mir/shell/basic_window_manager.h	2016-07-18 07:38:38 +0000
+++ src/include/server/mir/shell/basic_window_manager.h	2017-01-10 20:52:04 +0000
@@ -166,7 +166,7 @@
     int set_surface_attribute(
         std::shared_ptr<scene::Session> const& /*session*/,
         std::shared_ptr<scene::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     auto find_session(std::function<bool(SessionInfo const& info)> const& predicate)
 
=== modified file 'src/include/server/mir/shell/window_management_info.h'
--- src/include/server/mir/shell/window_management_info.h	2016-06-20 17:10:33 +0000
+++ src/include/server/mir/shell/window_management_info.h	2017-01-10 20:52:04 +0000
@@ -39,7 +39,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;
 
@@ -47,7 +47,7 @@
 
     bool is_visible() const;
 
-    static bool needs_titlebar(MirSurfaceType type);
+    static bool needs_titlebar(MirWindowType type);
 
     void constrain_resize(
         std::shared_ptr <scene::Surface> const& surface,
@@ -57,7 +57,7 @@
         const bool top_resize,
         geometry::Rectangle const& bounds) const;
 
-    MirSurfaceType type;
+    MirWindowType type;
     MirSurfaceState state;
     geometry::Rectangle restore_rect;
     std::weak_ptr <scene::Session> session;
 
=== modified file 'src/platforms/android/client/egl_native_surface_interpreter.cpp'
--- src/platforms/android/client/egl_native_surface_interpreter.cpp	2016-12-09 02:54:31 +0000
+++ src/platforms/android/client/egl_native_surface_interpreter.cpp	2017-01-10 20:52:04 +0000
@@ -92,7 +92,7 @@
 
 void mcla::EGLNativeSurfaceInterpreter::sync_to_display(bool should_sync)
 { 
-    surface.request_and_wait_for_configure(mir_surface_attrib_swapinterval, should_sync);
+    surface.request_and_wait_for_configure(mir_window_attrib_swapinterval, should_sync);
 }
 
 void mcla::EGLNativeSurfaceInterpreter::dispatch_driver_request_buffer_count(unsigned int count)
 
=== modified file 'src/platforms/mesa/client/native_surface.cpp'
--- src/platforms/mesa/client/native_surface.cpp	2017-01-09 06:48:47 +0000
+++ src/platforms/mesa/client/native_surface.cpp	2017-01-10 20:52:04 +0000
@@ -116,7 +116,7 @@
     if ((interval < 0) || (interval > 1))
         return MIR_MESA_FALSE;
 
-    surface->request_and_wait_for_configure(mir_surface_attrib_swapinterval, interval);
+    surface->request_and_wait_for_configure(mir_window_attrib_swapinterval, interval);
     return MIR_MESA_TRUE;
 }
 catch (std::exception const& e)
 
=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2016-12-23 15:33:03 +0000
+++ src/server/frontend/session_mediator.cpp	2017-01-10 20:52:04 +0000
@@ -241,7 +241,7 @@
         params.with_output_id(graphics::DisplayConfigurationOutputId(request->output_id()));
 
     if (request->has_type())
-        params.of_type(static_cast<MirSurfaceType>(request->type()));
+        params.of_type(static_cast<MirWindowType>(request->type()));
 
     if (request->has_state())
         params.with_state(static_cast<MirSurfaceState>(request->state()));
@@ -350,13 +350,13 @@
     if (surface->supports_input())
         response->add_fd(surface->client_input_fd());
     
-    for (unsigned int i = 0; i < mir_surface_attribs; i++)
+    for (unsigned int i = 0; i < mir_window_attribs; i++)
     {
         auto setting = response->add_attributes();
         
         setting->mutable_surfaceid()->set_value(surf_id.as_value());
         setting->set_attrib(i);
-        setting->set_ivalue(shell->get_surface_attribute(session, surf_id, static_cast<MirSurfaceAttrib>(i)));
+        setting->set_ivalue(shell->get_surface_attribute(session, surf_id, static_cast<MirWindowAttrib>(i)));
     }
 
     if (legacy_stream)
@@ -508,7 +508,7 @@
     mir::protobuf::SurfaceSetting* response,
     google::protobuf::Closure* done)
 {
-    MirSurfaceAttrib attrib = static_cast<MirSurfaceAttrib>(request->attrib());
+    auto attrib = static_cast<MirWindowAttrib>(request->attrib());
 
     // Required response fields:
     response->mutable_surfaceid()->CopyFrom(request->surfaceid());
 
=== modified file 'src/server/frontend/shell_wrapper.cpp'
--- src/server/frontend/shell_wrapper.cpp	2016-01-29 08:18:22 +0000
+++ src/server/frontend/shell_wrapper.cpp	2017-01-10 20:52:04 +0000
@@ -85,7 +85,7 @@
 int mf::ShellWrapper::set_surface_attribute(
     std::shared_ptr<Session> const& session,
     SurfaceId surface_id,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     return wrapped->set_surface_attribute(session, surface_id, attrib, value);
@@ -94,7 +94,7 @@
 int mf::ShellWrapper::get_surface_attribute(
     std::shared_ptr<Session> const& session,
     SurfaceId surface_id,
-    MirSurfaceAttrib attrib)
+    MirWindowAttrib attrib)
 {
     return wrapped->get_surface_attribute(session, surface_id, attrib);
 }
 
=== modified file 'src/server/frontend/shell_wrapper.h'
--- src/server/frontend/shell_wrapper.h	2016-01-29 08:18:22 +0000
+++ src/server/frontend/shell_wrapper.h	2017-01-10 20:52:04 +0000
@@ -67,13 +67,13 @@
     int set_surface_attribute(
         std::shared_ptr<Session> const& session,
         SurfaceId surface_id,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     int get_surface_attribute(
         std::shared_ptr<Session> const& session,
         SurfaceId surface_id,
-        MirSurfaceAttrib attrib) override;
+        MirWindowAttrib attrib) override;
 
     void raise_surface(
         std::shared_ptr<Session> const& session,
 
=== modified file 'src/server/input/cursor_controller.cpp'
--- src/server/input/cursor_controller.cpp	2016-01-29 08:18:22 +0000
+++ src/server/input/cursor_controller.cpp	2017-01-10 20:52:04 +0000
@@ -44,7 +44,7 @@
     {
     }
 
-    void attrib_changed(MirSurfaceAttrib, int) override
+    void attrib_changed(MirWindowAttrib, int) override
     {
         // Attribute changing alone wont trigger a cursor update
     }
 
=== modified file 'src/server/report/logging/shell_report.cpp'
--- src/server/report/logging/shell_report.cpp	2016-07-18 07:38:38 +0000
+++ src/server/report/logging/shell_report.cpp	2017-01-10 20:52:04 +0000
@@ -86,7 +86,7 @@
 void mrl::ShellReport::update_surface(
     Session const& session,
     Surface const& surface,
-    MirSurfaceAttrib /*attrib*/, int /*value*/)
+    MirWindowAttrib /*attrib*/, int /*value*/)
 {
     std::ostringstream out;
     log_basics(out, session, surface, "update");
 
=== modified file 'src/server/report/logging/shell_report.h'
--- src/server/report/logging/shell_report.h	2016-07-18 07:38:38 +0000
+++ src/server/report/logging/shell_report.h	2017-01-10 20:52:04 +0000
@@ -48,7 +48,7 @@
     void update_surface(
         scene::Session const& session,
         scene::Surface const& surface,
-        MirSurfaceAttrib attrib, int value) override;
+        MirWindowAttrib attrib, int value) override;
 
     void destroying_surface(
         scene::Session const& session,
 
=== modified file 'src/server/report/null/shell_report.cpp'
--- src/server/report/null/shell_report.cpp	2015-10-29 15:30:35 +0000
+++ src/server/report/null/shell_report.cpp	2017-01-10 20:52:04 +0000
@@ -44,7 +44,7 @@
 void mrn::ShellReport::update_surface(
     scene::Session const& /*session*/,
     scene::Surface const& /*surface*/,
-    MirSurfaceAttrib /*attrib*/, int /*value*/)
+    MirWindowAttrib /*attrib*/, int /*value*/)
 {
 }
 
 
=== modified file 'src/server/report/null/shell_report.h'
--- src/server/report/null/shell_report.h	2015-10-29 15:30:35 +0000
+++ src/server/report/null/shell_report.h	2017-01-10 20:52:04 +0000
@@ -45,7 +45,7 @@
     void update_surface(
         scene::Session const& /*session*/,
         scene::Surface const& /*surface*/,
-        MirSurfaceAttrib /*attrib*/, int /*value*/) override;
+        MirWindowAttrib /*attrib*/, int /*value*/) override;
 
     void destroying_surface(
         scene::Session const& /*session*/,
 
=== modified file 'src/server/scene/application_session.cpp'
--- src/server/scene/application_session.cpp	2016-11-09 02:30:14 +0000
+++ src/server/scene/application_session.cpp	2017-01-10 20:52:04 +0000
@@ -140,11 +140,11 @@
     surface_stack->add_surface(surface, params.input_mode);
 
     if (params.state.is_set())
-        surface->configure(mir_surface_attrib_state, params.state.value());
+        surface->configure(mir_window_attrib_state, params.state.value());
     if (params.type.is_set())
-        surface->configure(mir_surface_attrib_type, params.type.value());
+        surface->configure(mir_window_attrib_type, params.type.value());
     if (params.preferred_orientation.is_set())
-        surface->configure(mir_surface_attrib_preferred_orientation, params.preferred_orientation.value());
+        surface->configure(mir_window_attrib_preferred_orientation, params.preferred_orientation.value());
     if (params.input_shape.is_set())
         surface->set_input_region(params.input_shape.value());
 
@@ -211,17 +211,17 @@
         {
             switch (s.second->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 - skip it
                 return false;
 
=== modified file 'src/server/scene/basic_surface.cpp'
--- src/server/scene/basic_surface.cpp	2016-12-09 02:54:31 +0000
+++ src/server/scene/basic_surface.cpp	2017-01-10 20:52:04 +0000
@@ -49,7 +49,7 @@
 namespace geom = mir::geometry;
 namespace mrs = mir::renderer::software;
 
-void ms::SurfaceObservers::attrib_changed(MirSurfaceAttrib attrib, int value)
+void ms::SurfaceObservers::attrib_changed(MirWindowAttrib attrib, int value)
 {
     for_each([&](std::shared_ptr<SurfaceObserver> const& observer)
         { observer->attrib_changed(attrib, value); });
@@ -457,17 +457,17 @@
     observers.reception_mode_set_to(mode);
 }
 
-MirSurfaceType ms::BasicSurface::type() const
+MirWindowType ms::BasicSurface::type() const
 {    
     std::unique_lock<std::mutex> lg(guard);
     return type_;
 }
 
-MirSurfaceType ms::BasicSurface::set_type(MirSurfaceType t)
+MirWindowType ms::BasicSurface::set_type(MirWindowType t)
 {
     std::unique_lock<std::mutex> lg(guard);
     
-    if (t < 0 || t > mir_surface_types)
+    if (t < 0 || t > mir_window_types)
     {
         BOOST_THROW_EXCEPTION(std::logic_error("Invalid surface "
             "type."));
@@ -478,7 +478,7 @@
         type_ = t;
         lg.unlock();
 
-        observers.attrib_changed(mir_surface_attrib_type, type_); 
+        observers.attrib_changed(mir_window_attrib_type, type_); 
     }
 
     return t;
@@ -500,7 +500,7 @@
     {
         state_ = s;
         lg.unlock();
-        observers.attrib_changed(mir_surface_attrib_state, s);
+        observers.attrib_changed(mir_window_attrib_state, s);
     }
 
     return s;
@@ -522,7 +522,7 @@
             info.stream->allow_framedropping(allow_dropping);
 
         lg.unlock();
-        observers.attrib_changed(mir_surface_attrib_swapinterval, interval);
+        observers.attrib_changed(mir_window_attrib_swapinterval, interval);
     }
 
     return interval;
@@ -542,7 +542,7 @@
         focus_ = new_state;
 
         lg.unlock();
-        observers.attrib_changed(mir_surface_attrib_focus, new_state);
+        observers.attrib_changed(mir_window_attrib_focus, new_state);
     }
 
     return new_state;
@@ -561,36 +561,36 @@
         pref_orientation_mode = new_orientation_mode;
         lg.unlock();
 
-        observers.attrib_changed(mir_surface_attrib_preferred_orientation, new_orientation_mode);
+        observers.attrib_changed(mir_window_attrib_preferred_orientation, new_orientation_mode);
     }
 
     return new_orientation_mode;
 }
 
-int ms::BasicSurface::configure(MirSurfaceAttrib attrib, int value)
+int ms::BasicSurface::configure(MirWindowAttrib attrib, int value)
 {
     int result = value;
     switch (attrib)
     {
-    case mir_surface_attrib_type:
-        result = set_type(static_cast<MirSurfaceType>(result));
+    case mir_window_attrib_type:
+        result = set_type(static_cast<MirWindowType>(result));
         break;
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
         result = set_state(static_cast<MirSurfaceState>(result));
         break;
-    case mir_surface_attrib_focus:
+    case mir_window_attrib_focus:
         result = set_focus_state(static_cast<MirSurfaceFocusState>(result));
         break;
-    case mir_surface_attrib_swapinterval:
+    case mir_window_attrib_swapinterval:
         result = set_swap_interval(result);
         break;
-    case mir_surface_attrib_dpi:
+    case mir_window_attrib_dpi:
         result = set_dpi(result);
         break;
-    case mir_surface_attrib_visibility:
+    case mir_window_attrib_visibility:
         result = set_visibility(static_cast<MirSurfaceVisibility>(result));
         break;
-    case mir_surface_attrib_preferred_orientation:
+    case mir_window_attrib_preferred_orientation:
         result = set_preferred_orientation(static_cast<MirOrientationMode>(result));
         break;
     default:
@@ -600,18 +600,18 @@
     return result;
 }
 
-int ms::BasicSurface::query(MirSurfaceAttrib attrib) const
+int ms::BasicSurface::query(MirWindowAttrib attrib) const
 {
     std::unique_lock<std::mutex> lg(guard);
     switch (attrib)
     {
-        case mir_surface_attrib_type: return type_;
-        case mir_surface_attrib_state: return state_;
-        case mir_surface_attrib_swapinterval: return swapinterval_;
-        case mir_surface_attrib_focus: return focus_;
-        case mir_surface_attrib_dpi: return dpi_;
-        case mir_surface_attrib_visibility: return visibility_;
-        case mir_surface_attrib_preferred_orientation: return pref_orientation_mode;
+        case mir_window_attrib_type: return type_;
+        case mir_window_attrib_state: return state_;
+        case mir_window_attrib_swapinterval: return swapinterval_;
+        case mir_window_attrib_focus: return focus_;
+        case mir_window_attrib_dpi: return dpi_;
+        case mir_window_attrib_visibility: return visibility_;
+        case mir_window_attrib_preferred_orientation: return pref_orientation_mode;
         default: BOOST_THROW_EXCEPTION(std::logic_error("Invalid surface "
                                                         "attribute."));
     }
@@ -742,7 +742,7 @@
     {
         dpi_ = new_dpi;
         lg.unlock();
-        observers.attrib_changed(mir_surface_attrib_dpi, new_dpi);
+        observers.attrib_changed(mir_window_attrib_dpi, new_dpi);
     }
     
     return new_dpi;
@@ -766,7 +766,7 @@
             for (auto& info : layers)
                 info.stream->drop_old_buffers();
         }
-        observers.attrib_changed(mir_surface_attrib_visibility, visibility_);
+        observers.attrib_changed(mir_window_attrib_visibility, visibility_);
     }
 
     return new_visibility;
 
=== modified file 'src/server/scene/basic_surface.h'
--- src/server/scene/basic_surface.h	2016-12-09 02:54:31 +0000
+++ src/server/scene/basic_surface.h	2017-01-10 20:52:04 +0000
@@ -117,10 +117,10 @@
     graphics::RenderableList generate_renderables(compositor::CompositorID id) const override;
     int buffers_ready_for_compositor(void const* compositor_id) const override;
 
-    MirSurfaceType type() const override;
+    MirWindowType type() const override;
     MirSurfaceState state() const override;
-    int configure(MirSurfaceAttrib attrib, int value) override;
-    int query(MirSurfaceAttrib attrib) const override;
+    int configure(MirWindowAttrib attrib, int value) override;
+    int query(MirWindowAttrib attrib) const override;
     void hide() override;
     void show() override;
     
@@ -152,7 +152,7 @@
 
 private:
     bool visible(std::unique_lock<std::mutex>&) const;
-    MirSurfaceType set_type(MirSurfaceType t);  // Use configure() to make public changes
+    MirWindowType set_type(MirWindowType t);  // Use configure() to make public changes
     MirSurfaceState set_state(MirSurfaceState s);
     int set_dpi(int);
     MirSurfaceVisibility set_visibility(MirSurfaceVisibility v);
@@ -178,7 +178,7 @@
 
     std::list<StreamInfo> layers;
     // Surface attributes:
-    MirSurfaceType type_ = mir_surface_type_normal;
+    MirWindowType type_ = mir_window_type_normal;
     MirSurfaceState state_ = mir_surface_state_restored;
     int swapinterval_ = 1;
     MirSurfaceFocusState focus_ = mir_surface_unfocused;
 
=== modified file 'src/server/scene/legacy_surface_change_notification.cpp'
--- src/server/scene/legacy_surface_change_notification.cpp	2016-10-31 02:37:31 +0000
+++ src/server/scene/legacy_surface_change_notification.cpp	2017-01-10 20:52:04 +0000
@@ -67,7 +67,7 @@
 }
 
 // An attrib change alone is not enough to trigger recomposition.
-void ms::LegacySurfaceChangeNotification::attrib_changed(MirSurfaceAttrib /* attrib */, int /* value */)
+void ms::LegacySurfaceChangeNotification::attrib_changed(MirWindowAttrib /* attrib */, int /* value */)
 {
 }
 
 
=== modified file 'src/server/scene/legacy_surface_change_notification.h'
--- src/server/scene/legacy_surface_change_notification.h	2016-10-31 02:37:31 +0000
+++ src/server/scene/legacy_surface_change_notification.h	2017-01-10 20:52:04 +0000
@@ -41,7 +41,7 @@
     void alpha_set_to(float /*alpha*/) override;
     void orientation_set_to(MirOrientation orientation) override;
     void transformation_set_to(glm::mat4 const& /*t*/) override;
-    void attrib_changed(MirSurfaceAttrib, int) override;
+    void attrib_changed(MirWindowAttrib, int) override;
     void reception_mode_set_to(input::InputReceptionMode mode) override;
     void cursor_image_set_to(graphics::CursorImage const& image) override;
     void client_surface_close_requested() override;
 
=== modified file 'src/server/scene/null_surface_observer.cpp'
--- src/server/scene/null_surface_observer.cpp	2016-10-31 02:37:31 +0000
+++ src/server/scene/null_surface_observer.cpp	2017-01-10 20:52:04 +0000
@@ -21,7 +21,7 @@
 namespace ms = mir::scene;
 namespace mg = mir::graphics;
 
-void ms::NullSurfaceObserver::attrib_changed(MirSurfaceAttrib /*attrib*/, int /*value*/) {}
+void ms::NullSurfaceObserver::attrib_changed(MirWindowAttrib /*attrib*/, int /*value*/) {}
 void ms::NullSurfaceObserver::resized_to(geometry::Size const& /*size*/) {}
 void ms::NullSurfaceObserver::moved_to(geometry::Point const& /*top_left*/) {}
 void ms::NullSurfaceObserver::hidden_set_to(bool /*hide*/) {}
 
=== modified file 'src/server/scene/rendering_tracker.cpp'
--- src/server/scene/rendering_tracker.cpp	2016-01-29 08:18:22 +0000
+++ src/server/scene/rendering_tracker.cpp	2017-01-10 20:52:04 +0000
@@ -88,7 +88,7 @@
 void ms::RenderingTracker::configure_visibility(MirSurfaceVisibility visibility)
 {
     if (auto const surface = weak_surface.lock())
-        surface->configure(mir_surface_attrib_visibility, visibility);
+        surface->configure(mir_window_attrib_visibility, visibility);
 }
 
 void ms::RenderingTracker::remove_occlusions_for_inactive_compositors()
 
=== modified file 'src/server/scene/surface_creation_parameters.cpp'
--- src/server/scene/surface_creation_parameters.cpp	2016-01-29 08:18:22 +0000
+++ src/server/scene/surface_creation_parameters.cpp	2017-01-10 20:52:04 +0000
@@ -92,7 +92,7 @@
 }
 
 
-ms::SurfaceCreationParameters& ms::SurfaceCreationParameters::of_type(MirSurfaceType the_type)
+ms::SurfaceCreationParameters& ms::SurfaceCreationParameters::of_type(MirWindowType the_type)
 {
     type = the_type;
     return *this;
 
=== modified file 'src/server/scene/surface_event_source.cpp'
--- src/server/scene/surface_event_source.cpp	2016-10-31 02:37:31 +0000
+++ src/server/scene/surface_event_source.cpp	2017-01-10 20:52:04 +0000
@@ -65,7 +65,7 @@
     }
 }
 
-void ms::SurfaceEventSource::attrib_changed(MirSurfaceAttrib attrib, int value)
+void ms::SurfaceEventSource::attrib_changed(MirWindowAttrib attrib, int value)
 {
     event_sink->handle_event(*mev::make_event(id, attrib, value));
 }
 
=== modified file 'src/server/scene/surface_stack.cpp'
--- src/server/scene/surface_stack.cpp	2016-07-18 07:38:38 +0000
+++ src/server/scene/surface_stack.cpp	2017-01-10 20:52:04 +0000
@@ -309,7 +309,7 @@
     RecursiveReadLock lg(guard);
     for (auto &surface : surfaces)
     {
-        if (surface->query(mir_surface_attrib_visibility) ==
+        if (surface->query(mir_window_attrib_visibility) ==
             MirSurfaceVisibility::mir_surface_visibility_exposed)
         {
             callback(surface);
 
=== modified file 'src/server/shell/abstract_shell.cpp'
--- src/server/shell/abstract_shell.cpp	2016-11-09 02:30:14 +0000
+++ src/server/shell/abstract_shell.cpp	2017-01-10 20:52:04 +0000
@@ -209,7 +209,7 @@
 int msh::AbstractShell::set_surface_attribute(
     std::shared_ptr<ms::Session> const& session,
     std::shared_ptr<ms::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     report->update_surface(*session, *surface, attrib, value);
@@ -218,7 +218,7 @@
 
 int msh::AbstractShell::get_surface_attribute(
     std::shared_ptr<ms::Surface> const& surface,
-    MirSurfaceAttrib attrib)
+    MirWindowAttrib attrib)
 {
     return surface->query(attrib);
 }
@@ -289,7 +289,7 @@
 
         if (current_focus)
         {
-            current_focus->configure(mir_surface_attrib_focus, mir_surface_unfocused);
+            current_focus->configure(mir_window_attrib_focus, mir_surface_unfocused);
             current_focus->remove_observer(focus_surface_observer);
         }
 
@@ -303,7 +303,7 @@
             // Ensure the surface has really taken the focus before notifying it that it is focused
             input_targeter->set_focus(surface);
             surface->consume(seat->create_device_state().get());
-            surface->configure(mir_surface_attrib_focus, mir_surface_focused);
+            surface->configure(mir_window_attrib_focus, mir_surface_focused);
             surface->add_observer(focus_surface_observer);
         }
         else
 
=== modified file 'src/server/shell/basic_window_manager.cpp'
--- src/server/shell/basic_window_manager.cpp	2016-02-29 15:25:14 +0000
+++ src/server/shell/basic_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -138,13 +138,13 @@
 int msh::BasicWindowManager::set_surface_attribute(
     std::shared_ptr<scene::Session> const& /*session*/,
     std::shared_ptr<scene::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     std::lock_guard<decltype(mutex)> lock(mutex);
     switch (attrib)
     {
-    case mir_surface_attrib_state:
+    case mir_window_attrib_state:
     {
         auto const state = policy->handle_set_state(surface, MirSurfaceState(value));
         return surface->configure(attrib, state);
 
=== modified file 'src/server/shell/canonical_window_manager.cpp'
--- src/server/shell/canonical_window_manager.cpp	2016-12-09 02:54:31 +0000
+++ src/server/shell/canonical_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -41,12 +41,12 @@
 // but is currently used when placing the surface before construction.
 // Which implies we need some rework so that we can construct metadata
 // before the surface.
-bool must_not_have_parent(MirSurfaceType type)
+bool must_not_have_parent(MirWindowType type)
 {
     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:
@@ -58,13 +58,13 @@
 // but is currently used when placing the surface before construction.
 // Which implies we need some rework so that we can construct metadata
 // before the surface.
-bool must_have_parent(MirSurfaceType type)
+bool must_have_parent(MirWindowType type)
 {
     switch (type)
     {
-    case mir_surface_type_overlay:;
-    case mir_surface_type_satellite:
-    case mir_surface_type_tip:
+    case mir_window_type_gloss:;
+    case mir_window_type_satellite:
+    case mir_window_type_tip:
         return true;
 
     default:
@@ -334,7 +334,7 @@
                 throw std::runtime_error("Target surface type requires parent");
         }
 
-        surface->configure(mir_surface_attrib_type, new_type);
+        surface->configure(mir_window_attrib_type, new_type);
     }
 
     #define COPY_IF_SET(field)\
@@ -406,7 +406,7 @@
     if (modifications.state.is_set())
     {
         auto const state = handle_set_state(surface, modifications.state.value());
-        surface->configure(mir_surface_attrib_state, state);
+        surface->configure(mir_window_attrib_state, state);
     }
 
     if (modifications.confine_pointer.is_set())
@@ -780,7 +780,7 @@
             state = mir_surface_state_restored;
 
         auto const value = handle_set_state(surface, MirSurfaceState(state));
-        surface->configure(mir_surface_attrib_state, value);
+        surface->configure(mir_window_attrib_state, value);
     }
 }
 
 
=== modified file 'src/server/shell/frontend_shell.cpp'
--- src/server/shell/frontend_shell.cpp	2016-01-29 08:18:22 +0000
+++ src/server/shell/frontend_shell.cpp	2017-01-10 20:52:04 +0000
@@ -83,9 +83,9 @@
     //       in the surface spec requirements (eg: regular surface has no parent,
     //       dialog may have a parent, gloss must have a parent).
     if (populated_params.parent.lock() &&
-        populated_params.type.value() != mir_surface_type_inputmethod)
+        populated_params.type.value() != mir_window_type_inputmethod)
     {
-        BOOST_THROW_EXCEPTION(std::invalid_argument("Foreign parents may only be set on surfaces of type mir_surface_type_inputmethod"));
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Foreign parents may only be set on surfaces of type mir_window_type_inputmethod"));
     }
 
     if (populated_params.parent_id.is_set())
@@ -130,7 +130,7 @@
 int msh::FrontendShell::set_surface_attribute(
     std::shared_ptr<mf::Session> const& session,
     mf::SurfaceId surface_id,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
@@ -141,7 +141,7 @@
 int msh::FrontendShell::get_surface_attribute(
     std::shared_ptr<mf::Session> const& session,
     mf::SurfaceId surface_id,
-    MirSurfaceAttrib attrib)
+    MirWindowAttrib attrib)
 {
     auto const scene_session = std::dynamic_pointer_cast<ms::Session>(session);
     auto const surface = scene_session->surface(surface_id);
 
=== modified file 'src/server/shell/frontend_shell.h'
--- src/server/shell/frontend_shell.h	2016-01-29 08:18:22 +0000
+++ src/server/shell/frontend_shell.h	2017-01-10 20:52:04 +0000
@@ -79,13 +79,13 @@
     int set_surface_attribute(
         std::shared_ptr<mf::Session> const& session,
         mf::SurfaceId surface_id,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override;
 
     int get_surface_attribute(
         std::shared_ptr<mf::Session> const& session,
         mf::SurfaceId surface_id,
-        MirSurfaceAttrib attrib) override;
+        MirWindowAttrib attrib) override;
 
     void raise_surface(
         std::shared_ptr<mf::Session> const& session,
 
=== modified file 'src/server/shell/shell_wrapper.cpp'
--- src/server/shell/shell_wrapper.cpp	2016-01-29 08:18:22 +0000
+++ src/server/shell/shell_wrapper.cpp	2017-01-10 20:52:04 +0000
@@ -99,7 +99,7 @@
 int msh::ShellWrapper::set_surface_attribute(
     std::shared_ptr<ms::Session> const& session,
     std::shared_ptr<ms::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     return wrapped->set_surface_attribute(session, surface, attrib, value);
@@ -107,7 +107,7 @@
 
 int msh::ShellWrapper::get_surface_attribute(
     std::shared_ptr<ms::Surface> const& surface,
-    MirSurfaceAttrib attrib)
+    MirWindowAttrib attrib)
 {
     return wrapped->get_surface_attribute(surface, attrib);
 }
 
=== modified file 'src/server/shell/system_compositor_window_manager.cpp'
--- src/server/shell/system_compositor_window_manager.cpp	2016-07-18 07:38:38 +0000
+++ src/server/shell/system_compositor_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -168,7 +168,7 @@
 int msh::SystemCompositorWindowManager::set_surface_attribute(
     std::shared_ptr<ms::Session> const& /*session*/,
     std::shared_ptr<ms::Surface> const& surface,
-    MirSurfaceAttrib attrib,
+    MirWindowAttrib attrib,
     int value)
 {
     return surface->configure(attrib, value);
 
=== modified file 'src/server/shell/window_management_info.cpp'
--- src/server/shell/window_management_info.cpp	2016-02-29 15:25:14 +0000
+++ src/server/shell/window_management_info.cpp	2017-01-10 20:52:04 +0000
@@ -56,17 +56,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;
@@ -77,10 +77,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:
@@ -88,19 +88,19 @@
     }
 }
 
-bool msh::SurfaceInfo::can_morph_to(MirSurfaceType new_type) const
+bool msh::SurfaceInfo::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:
@@ -108,14 +108,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_popover:
+        case mir_window_type_satellite:
             return true;
 
         default:
@@ -134,8 +134,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:
@@ -284,15 +284,15 @@
     requested_size = new_size;
 }
 
-bool msh::SurfaceInfo::needs_titlebar(MirSurfaceType type)
+bool msh::SurfaceInfo::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:
 
=== modified file 'src/utils/vanity.c'
--- src/utils/vanity.c	2017-01-09 06:48:47 +0000
+++ src/utils/vanity.c	2017-01-10 20:52:04 +0000
@@ -135,12 +135,12 @@
     return false;
 }
 
-static bool on_surface_event(MirSurfaceEvent const* sevent, State* state)
+static bool on_surface_event(MirWindowEvent const* wevent, State* state)
 {
-    MirSurfaceAttrib attrib = mir_surface_event_get_attribute(sevent);
-    int value = mir_surface_event_get_attribute_value(sevent);
+    MirWindowAttrib attrib = mir_window_event_get_attribute(wevent);
+    int value = mir_window_event_get_attribute_value(wevent);
 
-    if (attrib == mir_surface_attrib_visibility)
+    if (attrib == mir_window_attrib_visibility)
     {
         if (value == mir_surface_visibility_exposed)
         {
@@ -172,8 +172,8 @@
     case mir_event_type_input:
         handled = on_input_event(mir_event_get_input_event(event), state);
         break;
-    case mir_event_type_surface:
-        handled = on_surface_event(mir_event_get_surface_event(event), state);
+    case mir_event_type_window:
+        handled = on_surface_event(mir_event_get_window_event(event), state);
         break;
     case mir_event_type_resize:
         state->resized = true;
 
=== modified file 'tests/acceptance-tests/test_client_cookie.cpp'
--- tests/acceptance-tests/test_client_cookie.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_cookie.cpp	2017-01-10 20:52:04 +0000
@@ -101,20 +101,20 @@
     auto const event_type = mir_event_get_type(ev);
     auto client_cookie = static_cast<ClientCookies*>(ctx);
 
-    if (event_type == mir_event_type_surface)
+    if (event_type == mir_event_type_window)
     {
-        auto event = mir_event_get_surface_event(ev);
-        auto const attrib = mir_surface_event_get_attribute(event);
-        auto const value = mir_surface_event_get_attribute_value(event);
+        auto event = mir_event_get_window_event(ev);
+        auto const attrib = mir_window_event_get_attribute(event);
+        auto const value = mir_window_event_get_attribute_value(event);
 
         std::lock_guard<std::mutex> lk(client_cookie->mutex);
-        if (attrib == mir_surface_attrib_visibility &&
+        if (attrib == mir_window_attrib_visibility &&
             value == mir_surface_visibility_exposed)
         {
             client_cookie->exposed = true;
         }
 
-        if (attrib == mir_surface_attrib_focus &&
+        if (attrib == mir_window_attrib_focus &&
             value == mir_surface_focused)
         {
             client_cookie->focused = true;
 
=== modified file 'tests/acceptance-tests/test_client_focus_notification.cpp'
--- tests/acceptance-tests/test_client_focus_notification.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_focus_notification.cpp	2017-01-10 20:52:04 +0000
@@ -57,14 +57,15 @@
 
     static void handle_event(MirWindow* window, MirEvent const* ev, void* context)
     {
-        if (mir_event_type_surface == mir_event_get_type(ev))
+        if (mir_event_type_window == mir_event_get_type(ev))
         {
-            auto surface_ev = mir_event_get_surface_event(ev);
-            if (mir_surface_attrib_focus == mir_surface_event_get_attribute(surface_ev))
+            auto surface_ev = mir_event_get_window_event(ev);
+            auto attrib = mir_window_event_get_attribute(surface_ev);
+            if (mir_window_attrib_focus == attrib)
             {
                 auto self = static_cast<FocusSurface*>(context);
                 self->log_focus_event(window,
-                    static_cast<MirSurfaceFocusState>(mir_surface_event_get_attribute_value(surface_ev)));
+                    static_cast<MirSurfaceFocusState>(mir_window_event_get_attribute_value(surface_ev)));
             }
         }
     }
 
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2017-01-10 20:52:04 +0000
@@ -112,16 +112,16 @@
             BOOST_THROW_EXCEPTION(std::runtime_error("Timeout waiting for window to become focused and exposed"));
     }
 
-    void handle_surface_event(MirSurfaceEvent const* event)
+    void handle_window_event(MirWindowEvent const* event)
     {
-        auto const attrib = mir_surface_event_get_attribute(event);
-        auto const value = mir_surface_event_get_attribute_value(event);
+        auto const attrib = mir_window_event_get_attribute(event);
+        auto const value = mir_window_event_get_attribute_value(event);
 
-        if (mir_surface_attrib_visibility == attrib &&
+        if (mir_window_attrib_visibility == attrib &&
             mir_surface_visibility_exposed == value)
             exposed = true;
 
-        if (mir_surface_attrib_focus == attrib &&
+        if (mir_window_attrib_focus == attrib &&
             mir_surface_focused == value)
             focused = true;
 
@@ -133,10 +133,10 @@
     {
         auto const client = static_cast<Client*>(context);
         auto type = mir_event_get_type(ev);
-        if (type == mir_event_type_surface)
+        if (type == mir_event_type_window)
         {
-            auto surface_event = mir_event_get_surface_event(ev);
-            client->handle_surface_event(surface_event);
+            auto window_event = mir_event_get_window_event(ev);
+            client->handle_window_event(window_event);
 
         }
         if (type == mir_event_type_input)
 
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2017-01-09 07:03:12 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2017-01-10 20:52:04 +0000
@@ -767,7 +767,7 @@
 
     EXPECT_THAT(native_buffer->width, Eq(width));
     EXPECT_THAT(native_buffer->height, Eq(height));
-    EXPECT_THAT(mir_surface_get_type(window), Eq(mir_surface_type_normal));
+    EXPECT_THAT(mir_window_get_type(window), Eq(mir_window_type_normal));
 
     mir_window_release_sync(window);
     mir_connection_release(connection);
@@ -793,7 +793,7 @@
 
     EXPECT_THAT(native_buffer->width, Eq(width));
     EXPECT_THAT(native_buffer->height, Eq(height));
-    EXPECT_THAT(mir_surface_get_type(window), Eq(mir_surface_type_normal));
+    EXPECT_THAT(mir_window_get_type(window), Eq(mir_window_type_normal));
 
     mir_window_release_sync(window);
     mir_connection_release(connection);
 
=== modified file 'tests/acceptance-tests/test_client_surface_events.cpp'
--- tests/acceptance-tests/test_client_surface_events.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_surface_events.cpp	2017-01-10 20:52:04 +0000
@@ -51,12 +51,56 @@
 
 namespace
 {
+// Assert our MirSurfaceAttrib is 1to1 to MirWindowAttrib
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_type) ==
+    static_cast<int32_t>(mir_window_attrib_type),
+    "mir_surface_attrib_type != mir_window_attrib_type");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_state) ==
+    static_cast<int32_t>(mir_window_attrib_state),
+    "mir_surface_attrib_state != mir_window_attrib_state");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_swapinterval) ==
+    static_cast<int32_t>(mir_window_attrib_swapinterval),
+    "mir_surface_attrib_swapinterval != mir_window_attrib_swapinterval");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_focus) ==
+    static_cast<int32_t>(mir_window_attrib_focus),
+    "mir_surface_attrib_focus != mir_window_attrib_focus");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_dpi) ==
+    static_cast<int32_t>(mir_window_attrib_dpi),
+    "mir_surface_attrib_dpi != mir_window_attrib_dpi");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_visibility) ==
+    static_cast<int32_t>(mir_window_attrib_visibility),
+    "mir_surface_attrib_visibility != mir_window_attrib_visibility");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attrib_preferred_orientation) ==
+    static_cast<int32_t>(mir_window_attrib_preferred_orientation),
+    "mir_surface_attrib_preferred_orientation != mir_window_attrib_preferred_orientation");
+
+static_assert(
+    static_cast<int32_t>(mir_surface_attribs) ==
+    static_cast<int32_t>(mir_window_attribs),
+    "mir_surface_attribs != mir_window_attribs");
+
+static_assert(sizeof(MirSurfaceAttrib) == sizeof(MirWindowAttrib),
+    "sizeof(MirSurfaceAttrib) != sizeof(MirWindowAttrib)");
+
 struct ClientSurfaceEvents : mtf::ConnectedClientWithASurface
 {
     MirSurface* other_surface;
 
     std::mutex last_event_mutex;
-    MirEventType event_filter{mir_event_type_surface};
+    MirEventType event_filter{mir_event_type_window};
     std::condition_variable last_event_cv;
     MirEvent const* last_event = nullptr;
     MirSurface* last_event_surface = nullptr;
@@ -158,14 +202,14 @@
 
         std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
 
-        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_fullscreen));
+        EXPECT_THAT(last_event, mt::WindowEvent(mir_window_attrib_state, mir_surface_state_fullscreen));
     }
 
     {
         mir_wait_for(mir_surface_set_state(window, static_cast<MirSurfaceState>(999)));
 
         std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
-        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_fullscreen));
+        EXPECT_THAT(last_event, mt::WindowEvent(mir_window_attrib_state, mir_surface_state_fullscreen));
     }
 
     reset_last_event();
@@ -175,7 +219,7 @@
 
         std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
 
-        EXPECT_THAT(last_event, mt::SurfaceEvent(mir_surface_attrib_state, mir_surface_state_vertmaximized));
+        EXPECT_THAT(last_event, mt::WindowEvent(mir_window_attrib_state, mir_surface_state_vertmaximized));
     }
 
     reset_last_event();
@@ -232,7 +276,7 @@
 
 TEST_F(ClientSurfaceEvents, surface_receives_close_event)
 {
-    set_event_filter(mir_event_type_close_surface);
+    set_event_filter(mir_event_type_close_window);
 
     scene_surface->request_client_surface_close();
 
@@ -241,7 +285,7 @@
     std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
 
     EXPECT_THAT(last_event_surface, Eq(window));
-    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_close_surface));
+    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_close_window));
 }
 
 TEST_F(ClientSurfaceEvents, client_can_query_preferred_orientation)
@@ -281,7 +325,7 @@
 
     ASSERT_FALSE(current_mode.empty());
 
-    set_event_filter(mir_event_type_surface_output);
+    set_event_filter(mir_event_type_window_output);
     reset_last_event();
 
     auto display_controller = server.the_display_configuration_controller();
@@ -291,20 +335,20 @@
 
     std::lock_guard<decltype(last_event_mutex)> last_event_lock{last_event_mutex};
 
-    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_surface_output));
-    auto output_event = mir_event_get_surface_output_event(last_event);
-
-    EXPECT_THAT(mir_surface_output_event_get_form_factor(output_event), Eq(form_factor));
-    EXPECT_THAT(mir_surface_output_event_get_scale(output_event), FloatEq(scale));
-
-    auto id = mir_surface_output_event_get_output_id(output_event);
+    EXPECT_THAT(mir_event_get_type(last_event), Eq(mir_event_type_window_output));
+    auto output_event = mir_event_get_window_output_event(last_event);
+
+    EXPECT_THAT(mir_window_output_event_get_form_factor(output_event), Eq(form_factor));
+    EXPECT_THAT(mir_window_output_event_get_scale(output_event), FloatEq(scale));
+
+    auto id = mir_window_output_event_get_output_id(output_event);
     ASSERT_THAT(current_mode.find(id), Ne(current_mode.end()));
-    EXPECT_THAT(mir_surface_output_event_get_refresh_rate(output_event), Eq(current_mode[id].vrefresh_hz));
+    EXPECT_THAT(mir_window_output_event_get_refresh_rate(output_event), Eq(current_mode[id].vrefresh_hz));
 }
 
 TEST_F(ClientSurfaceEvents, can_unset_surface_event_handler)
 {
-    set_event_filter(mir_event_type_close_surface);
+    set_event_filter(mir_event_type_close_window);
 
     mir_window_set_event_handler(window, nullptr, nullptr);
     scene_surface->request_client_surface_close();
@@ -316,17 +360,18 @@
 {
 bool is_focus_event_with_value(MirEvent const* event, MirSurfaceFocusState state)
 {
-    if (mir_event_get_type(event) != mir_event_type_surface)
+    if (mir_event_get_type(event) != mir_event_type_window)
     {
         return false;
     }
 
-    auto surface_event = mir_event_get_surface_event(event);
-    if (mir_surface_event_get_attribute(surface_event) != mir_surface_attrib_focus)
+    auto window_event = mir_event_get_window_event(event);
+    auto attrib = mir_window_event_get_attribute(window_event);
+    if (attrib != mir_window_attrib_focus)
     {
         return false;
     }
-    return mir_surface_event_get_attribute_value(surface_event) == state;
+    return mir_window_event_get_attribute_value(window_event) == state;
 }
 
 bool is_focus_event(MirEvent const* event)
@@ -467,7 +512,7 @@
 
 void raise_signal_on_close_event(MirSurface*, MirEvent const* ev, void* ctx)
 {
-    if (mir_event_get_type(ev) == mir_event_type_close_surface)
+    if (mir_event_get_type(ev) == mir_event_type_close_window)
     {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
@@ -521,7 +566,7 @@
 
 void surface_output_capturing_callback(MirSurface*, MirEvent const* ev, void* ctx)
 {
-    if (mir_event_get_type(ev) == mir_event_type_surface_output)
+    if (mir_event_get_type(ev) == mir_event_type_window_output)
     {
         auto out_event = reinterpret_cast<EventContext*>(ctx);
         out_event->event = mir_event_ref(ev);
@@ -558,7 +603,7 @@
 
         ASSERT_FALSE(current_mode.empty());
 
-        set_event_filter(mir_event_type_surface_output);
+        set_event_filter(mir_event_type_window_output);
         reset_last_event();
 
         auto const display_controller = server.the_display_configuration_controller();
@@ -581,14 +626,14 @@
     mir_window_spec_release(spec);
 
     ASSERT_TRUE(context.captured.wait_for(10s));
-    ASSERT_THAT(mir_event_get_type(context.event), Eq(mir_event_type_surface_output));
-    auto surface_event = mir_event_get_surface_output_event(context.event);
-    EXPECT_THAT(mir_surface_output_event_get_form_factor(surface_event), Eq(form_factor));
-    EXPECT_THAT(mir_surface_output_event_get_scale(surface_event), Eq(scale));
-    auto id = mir_surface_output_event_get_output_id(surface_event);
+    ASSERT_THAT(mir_event_get_type(context.event), Eq(mir_event_type_window_output));
+    auto window_event = mir_event_get_window_output_event(context.event);
+    EXPECT_THAT(mir_window_output_event_get_form_factor(window_event), Eq(form_factor));
+    EXPECT_THAT(mir_window_output_event_get_scale(window_event), Eq(scale));
+    auto id = mir_window_output_event_get_output_id(window_event);
     EXPECT_THAT(display_ids, Contains(Eq(id)));
     ASSERT_THAT(current_mode.find(id), Ne(current_mode.end()));
-    EXPECT_THAT(mir_surface_output_event_get_refresh_rate(surface_event),
+    EXPECT_THAT(mir_window_output_event_get_refresh_rate(window_event),
                 Eq(current_mode[id].vrefresh_hz));
 
     mir_window_release_sync(window);
 
=== modified file 'tests/acceptance-tests/test_client_surface_visibility.cpp'
--- tests/acceptance-tests/test_client_surface_visibility.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_surface_visibility.cpp	2017-01-10 20:52:04 +0000
@@ -90,17 +90,18 @@
 
 void event_callback(MirWindow* window, MirEvent const* event, void* ctx)
 {
-    if (mir_event_get_type(event) != mir_event_type_surface)
+    if (mir_event_get_type(event) != mir_event_type_window)
         return;
-    auto sev = mir_event_get_surface_event(event);
-    if (mir_surface_event_get_attribute(sev) != mir_surface_attrib_visibility)
+    auto sev = mir_event_get_window_event(event);
+    auto attrib = mir_window_event_get_attribute(sev);
+    if (attrib != mir_window_attrib_visibility)
         return;
 
     auto const mock_callback =
         reinterpret_cast<testing::NiceMock<MockVisibilityCallback>*>(ctx);
     mock_callback->handle(
         window,
-        static_cast<MirSurfaceVisibility>(mir_surface_event_get_attribute_value(sev)));
+        static_cast<MirSurfaceVisibility>(mir_window_event_get_attribute_value(sev)));
 }
 
 MirSurface* create_surface(MirConnection* connection, const char* name, geom::Size size,
 
=== modified file 'tests/acceptance-tests/test_client_surfaces.cpp'
--- tests/acceptance-tests/test_client_surfaces.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_client_surfaces.cpp	2017-01-10 20:52:04 +0000
@@ -176,7 +176,7 @@
     mir_window_spec_release(spec);
 
     ASSERT_THAT(menu, IsValid());
-    EXPECT_EQ(mir_surface_get_type(menu), mir_surface_type_menu);
+    EXPECT_EQ(mir_window_get_type(menu), mir_window_type_menu);
 
     mir_window_release_sync(parent);
     mir_window_release_sync(menu);
@@ -196,7 +196,7 @@
     mir_window_spec_release(spec);
 
     ASSERT_THAT(tooltip, IsValid());
-    EXPECT_EQ(mir_surface_get_type(tooltip), mir_surface_type_tip);
+    EXPECT_EQ(mir_window_get_type(tooltip), mir_window_type_tip);
 
     mir_window_release_sync(parent);
     mir_window_release_sync(tooltip);
@@ -212,7 +212,7 @@
     mir_window_spec_release(spec);
 
     ASSERT_THAT(dialog, IsValid());
-    EXPECT_EQ(mir_surface_get_type(dialog), mir_surface_type_dialog);
+    EXPECT_EQ(mir_window_get_type(dialog), mir_window_type_dialog);
 
     mir_window_release_sync(dialog);
 }
@@ -228,7 +228,7 @@
     mir_window_spec_release(spec);
 
     ASSERT_THAT(dialog, IsValid());
-    EXPECT_EQ(mir_surface_get_type(dialog), mir_surface_type_dialog);
+    EXPECT_EQ(mir_window_get_type(dialog), mir_window_type_dialog);
 
     mir_window_release_sync(parent);
     mir_window_release_sync(dialog);
@@ -243,7 +243,7 @@
     auto im = mir_window_create_sync(spec);
     mir_window_spec_release(spec);
 
-    EXPECT_EQ(mir_surface_get_type(im), mir_surface_type_inputmethod);
+    EXPECT_EQ(mir_window_get_type(im), mir_window_type_inputmethod);
 
     mir_window_release_sync(im);
 }
 
=== modified file 'tests/acceptance-tests/test_confined_pointer.cpp'
--- tests/acceptance-tests/test_confined_pointer.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_confined_pointer.cpp	2017-01-10 20:52:04 +0000
@@ -110,16 +110,16 @@
         mir_window_spec_release(spec);
     }
 
-    void handle_surface_event(MirSurfaceEvent const* event)
+    void handle_window_event(MirSurfaceEvent const* event)
     {
-        auto const attrib = mir_surface_event_get_attribute(event);
-        auto const value = mir_surface_event_get_attribute_value(event);
+        auto const attrib = mir_window_event_get_attribute(event);
+        auto const value = mir_window_event_get_attribute_value(event);
 
-        if (mir_surface_attrib_visibility == attrib &&
+        if (mir_window_attrib_visibility == attrib &&
             mir_surface_visibility_exposed == value)
             exposed = true;
 
-        if (mir_surface_attrib_focus == attrib &&
+        if (mir_window_attrib_focus == attrib &&
             mir_surface_focused == value)
             focused = true;
 
@@ -133,8 +133,8 @@
         auto type = mir_event_get_type(ev);
         switch (type)
         {
-        case mir_event_type_surface:
-            client->handle_surface_event(mir_event_get_surface_event(ev));
+        case mir_event_type_window:
+            client->handle_window_event(mir_event_get_window_event(ev));
             break;
         case mir_event_type_input:
             client->handle_input(ev);
 
=== modified file 'tests/acceptance-tests/test_custom_window_management.cpp'
--- tests/acceptance-tests/test_custom_window_management.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_custom_window_management.cpp	2017-01-10 20:52:04 +0000
@@ -19,6 +19,7 @@
 #include "mir/geometry/rectangle.h"
 #include "mir/scene/session.h"
 #include "mir_toolkit/events/surface_placement.h"
+#include "mir_toolkit/events/window_placement.h"
 #include "mir/events/event_builders.h"
 #include "mir/scene/surface.h"
 
@@ -279,7 +280,7 @@
 
         mt::Signal received;
 
-        EXPECT_CALL(window_manager, set_surface_attribute(_, WeakPtrEq(server_surface[i]), mir_surface_attrib_state,_))
+        EXPECT_CALL(window_manager, set_surface_attribute(_, WeakPtrEq(server_surface[i]), mir_window_attrib_state,_))
             .WillOnce(WithArg<3>(Invoke([&](int value) { received.raise(); return value; })));
 
         mir_surface_set_state(client_surface[i], mir_surface_state_maximized);
@@ -529,12 +530,12 @@
 {
     PlacementCheck(MirRectangle const& placement) : expected_rect{placement} {}
 
-    void check(MirSurfacePlacementEvent const* placement_event)
+    void check(MirWindowPlacementEvent const* placement_event)
     {
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).top, Eq(expected_rect.top));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).left, Eq(expected_rect.left));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).height, Eq(expected_rect.height));
-        EXPECT_THAT(mir_surface_placement_get_relative_position(placement_event).width, Eq(expected_rect.width));
+        EXPECT_THAT(mir_window_placement_get_relative_position(placement_event).top, Eq(expected_rect.top));
+        EXPECT_THAT(mir_window_placement_get_relative_position(placement_event).left, Eq(expected_rect.left));
+        EXPECT_THAT(mir_window_placement_get_relative_position(placement_event).height, Eq(expected_rect.height));
+        EXPECT_THAT(mir_window_placement_get_relative_position(placement_event).width, Eq(expected_rect.width));
 
         received.raise();
     }
@@ -551,7 +552,7 @@
 
 void surface_placement_event_callback(MirSurface* /*window*/, MirEvent const* event, void* context)
 {
-    if (mir_event_get_type(event) == mir_event_type_surface_placement)
+    if (mir_event_get_type(event) == mir_event_type_window_placement)
     {
         auto const placement_event = mir_event_get_surface_placement_event(event);
         static_cast<PlacementCheck*>(context)->check(placement_event);
 
=== modified file 'tests/acceptance-tests/test_nested_input.cpp'
--- tests/acceptance-tests/test_nested_input.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_nested_input.cpp	2017-01-10 20:52:04 +0000
@@ -139,16 +139,16 @@
 
     MOCK_METHOD1(handle_input, void(MirEvent const*));
 
-    void handle_surface_event(MirSurfaceEvent const* event)
+    void handle_window_event(MirWindowEvent const* event)
     {
-        auto const attrib = mir_surface_event_get_attribute(event);
-        auto const value = mir_surface_event_get_attribute_value(event);
+        auto const attrib = mir_window_event_get_attribute(event);
+        auto const value = mir_window_event_get_attribute_value(event);
 
-        if (mir_surface_attrib_visibility == attrib &&
+        if (mir_window_attrib_visibility == attrib &&
             mir_surface_visibility_exposed == value)
             exposed = true;
 
-        if (mir_surface_attrib_focus == attrib &&
+        if (mir_window_attrib_focus == attrib &&
             mir_surface_focused == value)
             focused = true;
 
@@ -160,10 +160,10 @@
     {
         auto const client = static_cast<ExposedSurface*>(context);
         auto type = mir_event_get_type(ev);
-        if (type == mir_event_type_surface)
+        if (type == mir_event_type_window)
         {
-            auto surface_event = mir_event_get_surface_event(ev);
-            client->handle_surface_event(surface_event);
+            auto window_event = mir_event_get_window_event(ev);
+            client->handle_window_event(window_event);
 
         }
         if (type == mir_event_type_input)
 
=== modified file 'tests/acceptance-tests/test_nested_mir.cpp'
--- tests/acceptance-tests/test_nested_mir.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_nested_mir.cpp	2017-01-10 20:52:04 +0000
@@ -364,7 +364,7 @@
     int set_surface_attribute(
         std::shared_ptr<msc::Session> const& session,
         std::shared_ptr<msc::Surface> const& window,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int value) override
     {
         return wrapped->set_surface_attribute(session, window, attrib, value);
@@ -372,7 +372,7 @@
 
     int get_surface_attribute(
         std::shared_ptr<msc::Surface> const& window,
-        MirSurfaceAttrib attrib) override
+        MirWindowAttrib attrib) override
     {
         return wrapped->get_surface_attribute(window, attrib);
     }
@@ -778,11 +778,11 @@
     mt::Signal surface_event_received;
     mir_window_spec_set_event_handler(spec, [](MirSurface*, MirEvent const* event, void* ctx)
         {
-            if (mir_event_get_type(event) == mir_event_type_surface_output)
+            if (mir_event_get_type(event) == mir_event_type_window_output)
             {
-                auto surface_event = mir_event_get_surface_output_event(event);
-                EXPECT_THAT(mir_surface_output_event_get_form_factor(surface_event), Eq(expected_form_factor));
-                EXPECT_THAT(mir_surface_output_event_get_scale(surface_event), Eq(expected_scale));
+                auto surface_event = mir_event_get_window_output_event(event);
+                EXPECT_THAT(mir_window_output_event_get_form_factor(surface_event), Eq(expected_form_factor));
+                EXPECT_THAT(mir_window_output_event_get_scale(surface_event), Eq(expected_scale));
                 auto signal = static_cast<mt::Signal*>(ctx);
                 signal->raise();
             }
 
=== modified file 'tests/acceptance-tests/test_new_display_configuration.cpp'
--- tests/acceptance-tests/test_new_display_configuration.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_new_display_configuration.cpp	2017-01-10 20:52:04 +0000
@@ -281,14 +281,14 @@
     {
         auto const client = static_cast<SimpleClient*>(context);
         auto type = mir_event_get_type(ev);
-        if (type == mir_event_type_surface)
+        if (type == mir_event_type_window)
         {
-            auto surface_event = mir_event_get_surface_event(ev);
-            auto const attrib  = mir_surface_event_get_attribute(surface_event);
-            auto const value   = mir_surface_event_get_attribute_value(surface_event);
+            auto window_event = mir_event_get_window_event(ev);
+            auto const attrib  = mir_window_event_get_attribute(window_event);
+            auto const value   = mir_window_event_get_attribute_value(window_event);
 
             std::lock_guard<std::mutex> lk(client->mutex);
-            if (mir_surface_attrib_focus == attrib &&
+            if (mir_window_attrib_focus == attrib &&
                 mir_surface_focused == value)
                 client->ready_to_accept_events.raise();
         }
 
=== modified file 'tests/acceptance-tests/test_surface_morphing.cpp'
--- tests/acceptance-tests/test_surface_morphing.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_surface_morphing.cpp	2017-01-10 20:52:04 +0000
@@ -57,7 +57,7 @@
 {
 public:
     MOCK_METHOD1(renamed, void(char const*));
-    MOCK_METHOD2(attrib_changed, void(MirSurfaceAttrib attrib, int value));
+    MOCK_METHOD2(attrib_changed, void(MirWindowAttrib attrib, int value));
 };
 
 struct SurfaceMorphing : mtf::ConnectedClientHeadlessServer
@@ -158,8 +158,8 @@
 
 struct TypePair
 {
-    MirSurfaceType from;
-    MirSurfaceType to;
+    MirWindowType from;
+    MirWindowType to;
 
     friend std::ostream& operator<<(std::ostream& out, TypePair const& types)
         { return out << "from:" << types.from << ", to:" << types.to; }
@@ -187,7 +187,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
         WillOnce(InvokeWithoutArgs([&] { change_observed(); }));
 
     change_surface(window, [&](MirWindowSpec* spec)
@@ -203,7 +203,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -221,7 +221,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
         Times(0);
 
     change_surface(window, [&](MirWindowSpec* spec)
@@ -244,7 +244,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -262,7 +262,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
         WillOnce(InvokeWithoutArgs([&] { change_observed(); }));
 
     change_surface(window, [&](MirWindowSpec* spec)
@@ -288,7 +288,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
         Times(0);
 
     change_surface(window, [&](MirWindowSpec* spec)
@@ -310,7 +310,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -328,7 +328,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
         WillOnce(InvokeWithoutArgs([&] { change_observed(); }));
 
     change_surface(window, [&](MirWindowSpec* spec)
@@ -345,7 +345,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
        {
-           mir_window_spec_set_type(spec, mir_surface_type_normal);
+           mir_window_spec_set_type(spec, mir_window_type_normal);
            mir_window_spec_set_width(spec, width);
            mir_window_spec_set_height(spec, height);
            mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -363,7 +363,7 @@
 
     latest_shell_surface()->add_observer(mt::fake_shared(surface_observer));
 
-    EXPECT_CALL(surface_observer, attrib_changed(mir_surface_attrib_type, new_type)).
+    EXPECT_CALL(surface_observer, attrib_changed(mir_window_attrib_type, new_type)).
     WillOnce(InvokeWithoutArgs([&] { change_observed(); }));
 
 
@@ -375,21 +375,21 @@
 
 INSTANTIATE_TEST_CASE_P(SurfaceMorphing, TargetWithoutParent,
     Values(
-        TypePair{mir_surface_type_normal, mir_surface_type_utility},
-        TypePair{mir_surface_type_utility, mir_surface_type_normal},
-        TypePair{mir_surface_type_dialog, mir_surface_type_utility},
-        TypePair{mir_surface_type_dialog, mir_surface_type_normal}
+        TypePair{mir_window_type_normal, mir_window_type_utility},
+        TypePair{mir_window_type_utility, mir_window_type_normal},
+        TypePair{mir_window_type_dialog, mir_window_type_utility},
+        TypePair{mir_window_type_dialog, mir_window_type_normal}
     ));
 
 INSTANTIATE_TEST_CASE_P(SurfaceMorphing, TargetNeedingParent,
     Values(
-        TypePair{mir_surface_type_normal, mir_surface_type_satellite},
-        TypePair{mir_surface_type_utility, mir_surface_type_satellite},
-        TypePair{mir_surface_type_dialog, mir_surface_type_satellite}
+        TypePair{mir_window_type_normal, mir_window_type_satellite},
+        TypePair{mir_window_type_utility, mir_window_type_satellite},
+        TypePair{mir_window_type_dialog, mir_window_type_satellite}
     ));
 
 INSTANTIATE_TEST_CASE_P(SurfaceMorphing, TargetMayHaveParent,
     Values(
-        TypePair{mir_surface_type_normal, mir_surface_type_dialog},
-        TypePair{mir_surface_type_utility, mir_surface_type_dialog}
+        TypePair{mir_window_type_normal, mir_window_type_dialog},
+        TypePair{mir_window_type_utility, mir_window_type_dialog}
     ));
 
=== modified file 'tests/acceptance-tests/test_surface_placement.cpp'
--- tests/acceptance-tests/test_surface_placement.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_surface_placement.cpp	2017-01-10 20:52:04 +0000
@@ -461,7 +461,7 @@
     mir_window_release_sync(window);
 }
 
-struct UnparentedSurface : SurfacePlacement, ::testing::WithParamInterface<MirSurfaceType> {};
+struct UnparentedSurface : SurfacePlacement, ::testing::WithParamInterface<MirWindowType> {};
 
 TEST_P(UnparentedSurface, small_window_is_optically_centered_on_first_display)
 {
@@ -494,10 +494,10 @@
 
 INSTANTIATE_TEST_CASE_P(SurfacePlacement, UnparentedSurface,
     ::testing::Values(
-        mir_surface_type_normal,
-        mir_surface_type_utility,
-        mir_surface_type_dialog,
-        mir_surface_type_freestyle));
+        mir_window_type_normal,
+        mir_window_type_utility,
+        mir_window_type_dialog,
+        mir_window_type_freestyle));
 
 // Parented dialog or parented freestyle window
 //
@@ -519,7 +519,7 @@
 //    relative to its parent
 // TODO tests for this
 
-struct ParentedSurface : SurfacePlacement, ::testing::WithParamInterface<MirSurfaceType> {};
+struct ParentedSurface : SurfacePlacement, ::testing::WithParamInterface<MirWindowType> {};
 
 TEST_P(ParentedSurface, small_window_is_optically_centered_on_parent)
 {
@@ -557,9 +557,9 @@
 
 INSTANTIATE_TEST_CASE_P(SurfacePlacement, ParentedSurface,
     ::testing::Values(
-        mir_surface_type_dialog,
-        mir_surface_type_satellite,
-        mir_surface_type_popover,
-        mir_surface_type_gloss,
-        mir_surface_type_tip,
-        mir_surface_type_freestyle));
+        mir_window_type_dialog,
+        mir_window_type_satellite,
+        mir_window_type_popover,
+        mir_window_type_gloss,
+        mir_window_type_tip,
+        mir_window_type_freestyle));
 
=== modified file 'tests/acceptance-tests/test_surface_raise.cpp'
--- tests/acceptance-tests/test_surface_raise.cpp	2017-01-09 20:01:45 +0000
+++ tests/acceptance-tests/test_surface_raise.cpp	2017-01-10 20:52:04 +0000
@@ -112,21 +112,21 @@
     auto const event_type = mir_event_get_type(ev);
     auto raise_surfaces = static_cast<RaiseSurfaces*>(ctx);
 
-    if (event_type == mir_event_type_surface)
+    if (event_type == mir_event_type_window)
     {
-        auto event = mir_event_get_surface_event(ev);
-        auto const attrib = mir_surface_event_get_attribute(event);
-        auto const value = mir_surface_event_get_attribute_value(event);
+        auto event = mir_event_get_window_event(ev);
+        auto const attrib = mir_window_event_get_attribute(event);
+        auto const value = mir_window_event_get_attribute_value(event);
 
         std::lock_guard<std::mutex> lk(raise_surfaces->mutex);
 
-        if (attrib == mir_surface_attrib_visibility &&
+        if (attrib == mir_window_attrib_visibility &&
             value == mir_surface_visibility_exposed)
         {
             raise_surfaces->exposed = true;
         }
 
-        if (attrib == mir_surface_attrib_focus &&
+        if (attrib == mir_window_attrib_focus &&
             value == mir_surface_focused)
         {
             raise_surfaces->focused = true;
 
=== modified file 'tests/acceptance-tests/test_surface_specification.cpp'
--- tests/acceptance-tests/test_surface_specification.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_surface_specification.cpp	2017-01-10 20:52:04 +0000
@@ -48,7 +48,7 @@
 {
 public:
     MOCK_METHOD1(renamed, void(char const*));
-    MOCK_METHOD2(attrib_changed, void(MirSurfaceAttrib attrib, int value));
+    MOCK_METHOD2(attrib_changed, void(MirWindowAttrib attrib, int value));
     MOCK_METHOD1(resized_to, void(Size const& size));
 };
 
@@ -179,7 +179,7 @@
     }
 };
 
-struct SurfaceSpecificationCase : SurfaceSpecification, ::testing::WithParamInterface<MirSurfaceType> {};
+struct SurfaceSpecificationCase : SurfaceSpecification, ::testing::WithParamInterface<MirWindowType> {};
 using SurfaceWithoutParent = SurfaceSpecificationCase;
 using SurfaceNeedingParent = SurfaceSpecificationCase;
 using SurfaceMayHaveParent = SurfaceSpecificationCase;
@@ -210,7 +210,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -235,7 +235,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -260,7 +260,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -285,7 +285,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -310,7 +310,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -339,7 +339,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -368,7 +368,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -397,7 +397,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -427,7 +427,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -457,7 +457,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -494,7 +494,7 @@
 
     auto const surface = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -564,7 +564,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -590,7 +590,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -632,7 +632,7 @@
 
     auto const parent = create_surface([&](MirWindowSpec* spec)
         {
-            mir_window_spec_set_type(spec, mir_surface_type_normal);
+            mir_window_spec_set_type(spec, mir_window_type_normal);
             mir_window_spec_set_width(spec, width);
             mir_window_spec_set_height(spec, height);
             mir_window_spec_set_pixel_format(spec, pixel_format);
@@ -669,10 +669,10 @@
 }
 
 INSTANTIATE_TEST_CASE_P(SurfaceSpecification, SurfaceWithoutParent,
-    Values(mir_surface_type_utility, mir_surface_type_normal));
+    Values(mir_window_type_utility, mir_window_type_normal));
 
 INSTANTIATE_TEST_CASE_P(SurfaceSpecification, SurfaceNeedingParent,
-    Values(mir_surface_type_satellite, mir_surface_type_gloss, mir_surface_type_tip));
+    Values(mir_window_type_satellite, mir_window_type_gloss, mir_window_type_tip));
 
 INSTANTIATE_TEST_CASE_P(SurfaceSpecification, SurfaceMayHaveParent,
-    Values(mir_surface_type_dialog, mir_surface_type_freestyle));
+    Values(mir_window_type_dialog, mir_window_type_freestyle));
 
=== modified file 'tests/acceptance-tests/test_system_compositor_window_manager.cpp'
--- tests/acceptance-tests/test_system_compositor_window_manager.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/test_system_compositor_window_manager.cpp	2017-01-10 20:52:04 +0000
@@ -174,14 +174,14 @@
 
 MATCHER_P(MirFocusEvent, expected, "")
 {
-    if (mir_event_get_type(arg) != mir_event_type_surface)
+    if (mir_event_get_type(arg) != mir_event_type_window)
         return false;
 
-    auto surface_event = mir_event_get_surface_event(arg);
-    auto attrib = mir_surface_event_get_attribute(surface_event);
-    auto value = mir_surface_event_get_attribute_value(surface_event);
+    auto window_event = mir_event_get_window_event(arg);
+    auto attrib = mir_window_event_get_attribute(window_event);
+    auto value = mir_window_event_get_attribute_value(window_event);
 
-    return (attrib == mir_surface_attrib_focus)
+    return (attrib == mir_window_attrib_focus)
         && (value == expected);
 }
 }
 
=== modified file 'tests/acceptance-tests/throwback/test_shell_control_of_surface_configuration.cpp'
--- tests/acceptance-tests/throwback/test_shell_control_of_surface_configuration.cpp	2017-01-09 06:48:47 +0000
+++ tests/acceptance-tests/throwback/test_shell_control_of_surface_configuration.cpp	2017-01-10 20:52:04 +0000
@@ -42,12 +42,12 @@
     MOCK_METHOD4(set_surface_attribute,
         int(std::shared_ptr<ms::Session> const& session,
             std::shared_ptr<ms::Surface> const& surface,
-            MirSurfaceAttrib attrib,
+            MirWindowAttrib attrib,
             int value));
 
     int real_set_surface_attribute(std::shared_ptr<ms::Session> const& session,
                 std::shared_ptr<ms::Surface> const& surface,
-                MirSurfaceAttrib attrib,
+                MirWindowAttrib attrib,
                 int value)
     {
         return msh::CanonicalWindowManager::set_surface_attribute(session, surface, attrib, value);
@@ -70,7 +70,7 @@
                         mock_window_manager.get(), &MockWindowManager::real_set_surface_attribute));
 
                 EXPECT_CALL(*mock_window_manager,
-                    set_surface_attribute(_, _, Ne(mir_surface_attrib_state), _))
+                    set_surface_attribute(_, _, Ne(mir_window_attrib_state), _))
                     .Times(AnyNumber());
 
                 return mock_window_manager;
@@ -86,7 +86,7 @@
 TEST_F(ShellSurfaceConfiguration, the_window_manager_is_notified_of_attribute_changes)
 {
     EXPECT_CALL(*mock_window_manager,
-        set_surface_attribute(_, _, mir_surface_attrib_state, Eq(mir_surface_state_maximized)));
+        set_surface_attribute(_, _, mir_window_attrib_state, Eq(mir_surface_state_maximized)));
 
     mir_wait_for(mir_surface_set_state(window, mir_surface_state_maximized));
 
@@ -98,7 +98,7 @@
     auto const set_to_vertmax = [this](
         std::shared_ptr<ms::Session> const& session,
         std::shared_ptr<ms::Surface> const& surface,
-        MirSurfaceAttrib attrib,
+        MirWindowAttrib attrib,
         int /*value*/)
     {
         return mock_window_manager->real_set_surface_attribute(
@@ -106,7 +106,7 @@
     };
 
     EXPECT_CALL(*mock_window_manager,
-        set_surface_attribute(_, _, mir_surface_attrib_state, Eq(mir_surface_state_maximized)))
+        set_surface_attribute(_, _, mir_window_attrib_state, Eq(mir_surface_state_maximized)))
         .WillOnce(Invoke(set_to_vertmax));
 
     mir_wait_for(mir_surface_set_state(window, mir_surface_state_maximized));
 
=== modified file 'tests/include/mir/test/doubles/mock_egl_native_surface.h'
--- tests/include/mir/test/doubles/mock_egl_native_surface.h	2017-01-09 06:48:47 +0000
+++ tests/include/mir/test/doubles/mock_egl_native_surface.h	2017-01-10 20:52:04 +0000
@@ -35,7 +35,7 @@
     MOCK_CONST_METHOD0(get_parameters, MirWindowParameters());
     MOCK_METHOD0(get_current_buffer, std::shared_ptr<client::ClientBuffer>());
     MOCK_METHOD0(swap_buffers_sync, void());
-    MOCK_METHOD2(request_and_wait_for_configure, void(MirSurfaceAttrib,int));
+    MOCK_METHOD2(request_and_wait_for_configure, void(MirWindowAttrib,int));
     MOCK_METHOD1(set_buffer_cache_size, void(unsigned int));
 };
 
 
=== modified file 'tests/include/mir/test/doubles/mock_frontend_surface.h'
--- tests/include/mir/test/doubles/mock_frontend_surface.h	2015-06-18 02:46:16 +0000
+++ tests/include/mir/test/doubles/mock_frontend_surface.h	2017-01-10 20:52:04 +0000
@@ -63,9 +63,9 @@
     MOCK_METHOD1(set_cursor_image, void(std::shared_ptr<graphics::CursorImage> const&));
     MOCK_METHOD2(set_cursor_stream, void(std::shared_ptr<frontend::BufferStream> const&, geometry::Displacement const&));
 
-    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+    MOCK_METHOD2(configure, int(MirWindowAttrib, int));
 
-    MOCK_CONST_METHOD1(query, int(MirSurfaceAttrib));
+    MOCK_CONST_METHOD1(query, int(MirWindowAttrib));
 
     MOCK_METHOD1(add_observer, void(std::shared_ptr<scene::SurfaceObserver> const&));
     MOCK_METHOD1(remove_observer, void(std::weak_ptr<scene::SurfaceObserver> const&));
 
=== modified file 'tests/include/mir/test/doubles/mock_scene_session.h'
--- tests/include/mir/test/doubles/mock_scene_session.h	2016-09-29 03:56:21 +0000
+++ tests/include/mir/test/doubles/mock_scene_session.h	2017-01-10 20:52:04 +0000
@@ -59,7 +59,7 @@
     MOCK_METHOD1(send_display_config, void(graphics::DisplayConfiguration const&));
     MOCK_METHOD1(send_error, void(ClientVisibleError const&));
     MOCK_METHOD1(send_input_device_change, void(std::vector<std::shared_ptr<mir::input::Device>> const&));
-    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirSurfaceAttrib, int));
+    MOCK_METHOD3(configure_surface, int(frontend::SurfaceId, MirWindowAttrib, int));
 
     MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState state));
 
 
=== modified file 'tests/include/mir/test/doubles/mock_shell.h'
--- tests/include/mir/test/doubles/mock_shell.h	2016-01-29 08:18:22 +0000
+++ tests/include/mir/test/doubles/mock_shell.h	2017-01-10 20:52:04 +0000
@@ -65,10 +65,10 @@
 
     MOCK_METHOD4(set_surface_attribute, int(
         std::shared_ptr<frontend::Session> const& session, frontend::SurfaceId surface_id,
-        MirSurfaceAttrib attrib, int value));
+        MirWindowAttrib attrib, int value));
 
     MOCK_METHOD3(get_surface_attribute, int(std::shared_ptr<frontend::Session> const& session,
-        frontend::SurfaceId surface_id, MirSurfaceAttrib attrib));
+        frontend::SurfaceId surface_id, MirWindowAttrib attrib));
 
     MOCK_METHOD3(raise_surface, void(std::shared_ptr<frontend::Session> const& session,
         frontend::SurfaceId surface_id, uint64_t timestamp));
 
=== modified file 'tests/include/mir/test/doubles/mock_surface.h'
--- tests/include/mir/test/doubles/mock_surface.h	2016-08-25 08:16:10 +0000
+++ tests/include/mir/test/doubles/mock_surface.h	2017-01-10 20:52:04 +0000
@@ -69,7 +69,7 @@
     MOCK_CONST_METHOD0(supports_input, bool());
     MOCK_CONST_METHOD0(client_input_fd, int());
 
-    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+    MOCK_METHOD2(configure, int(MirWindowAttrib, int));
     MOCK_METHOD1(add_observer, void(std::shared_ptr<scene::SurfaceObserver> const&));
     MOCK_METHOD1(remove_observer, void(std::weak_ptr<scene::SurfaceObserver> const&));
     MOCK_METHOD1(consume, void(MirEvent const*));
 
=== modified file 'tests/include/mir/test/doubles/stub_scene_surface.h'
--- tests/include/mir/test/doubles/stub_scene_surface.h	2016-10-31 02:37:31 +0000
+++ tests/include/mir/test/doubles/stub_scene_surface.h	2017-01-10 20:52:04 +0000
@@ -67,7 +67,7 @@
     int buffers_ready_for_compositor(void const*) const override { return 0; }
 
     float alpha() const override { return 0.0f;}
-    MirSurfaceType type() const override { return mir_surface_type_normal; }
+    MirWindowType type() const override { return mir_window_type_normal; }
     MirSurfaceState state() const override { return mir_surface_state_unknown; }
 
     void hide() override {}
@@ -93,8 +93,8 @@
 
     bool supports_input() const override { return true;}
     int client_input_fd() const override { return fd;}
-    int configure(MirSurfaceAttrib, int) override { return 0; }
-    int query(MirSurfaceAttrib) const override { return 0; }
+    int configure(MirWindowAttrib, int) override { return 0; }
+    int query(MirWindowAttrib) const override { return 0; }
     void with_most_recent_buffer_do(std::function<void(graphics::Buffer&)> const&) {}
 
     std::shared_ptr<mir::scene::Surface> parent() const override { return nullptr; }
 
=== modified file 'tests/integration-tests/client/test_mirsurface.cpp'
--- tests/integration-tests/client/test_mirsurface.cpp	2017-01-09 06:48:47 +0000
+++ tests/integration-tests/client/test_mirsurface.cpp	2017-01-10 20:52:04 +0000
@@ -80,17 +80,17 @@
 
 MATCHER(IsAMenu, "")
 {
-    return arg.type == mir_surface_type_menu;
+    return arg.type == mir_window_type_menu;
 }
 
 MATCHER(IsATooltip, "")
 {
-    return arg.type == mir_surface_type_tip;
+    return arg.type == mir_window_type_tip;
 }
 
 MATCHER(IsADialog, "")
 {
-    return arg.type == mir_surface_type_dialog;
+    return arg.type == mir_window_type_dialog;
 }
 
 MATCHER_P(HasParent, parent, "")
@@ -143,7 +143,7 @@
         spec.buffer_usage = mir_buffer_usage_software;
         spec.surface_name = "test_surface";
         spec.output_id = mir_display_output_id_invalid;
-        spec.type = mir_surface_type_dialog;
+        spec.type = mir_window_type_dialog;
         spec.state = mir_surface_state_minimized;
         spec.pref_orientation = mir_orientation_mode_landscape;
     }
 
=== modified file 'tests/integration-tests/session_management.cpp'
--- tests/integration-tests/session_management.cpp	2016-05-27 07:54:00 +0000
+++ tests/integration-tests/session_management.cpp	2017-01-10 20:52:04 +0000
@@ -131,7 +131,7 @@
         mir::geometry::Size{1,1}, mir_pixel_format_abgr_8888, mir::graphics::BufferUsage::software);
     ms::SurfaceCreationParameters const params = ms::SurfaceCreationParameters()
         .of_size(100,100)
-        .of_type(mir_surface_type_normal)
+        .of_type(mir_window_type_normal)
         .with_buffer_stream(session->create_buffer_stream(properties));
 
     EXPECT_CALL(*test_surface_stack, add_surface(_,_)).Times(1);
 
=== modified file 'tests/integration-tests/test_session.cpp'
--- tests/integration-tests/test_session.cpp	2016-11-04 17:12:59 +0000
+++ tests/integration-tests/test_session.cpp	2017-01-10 20:52:04 +0000
@@ -117,7 +117,7 @@
     auto compositor = conf.the_compositor();
 
     compositor->start();
-    session.default_surface()->configure(mir_surface_attrib_swapinterval, 0);
+    session.default_surface()->configure(mir_window_attrib_swapinterval, 0);
 
     std::thread client_thread{
         [&session, stream_id]
 
=== modified file 'tests/mir_test_framework/stub_surface.cpp'
--- tests/mir_test_framework/stub_surface.cpp	2016-10-31 02:37:31 +0000
+++ tests/mir_test_framework/stub_surface.cpp	2017-01-10 20:52:04 +0000
@@ -131,9 +131,9 @@
     return 0;
 }
 
-MirSurfaceType mtd::StubSurface::type() const
+MirWindowType mtd::StubSurface::type() const
 {
-    return MirSurfaceType::mir_surface_type_normal;
+    return MirWindowType::mir_window_type_normal;
 }
 
 MirSurfaceState mtd::StubSurface::state() const
@@ -141,12 +141,12 @@
     return MirSurfaceState::mir_surface_state_fullscreen;
 }
 
-int mtd::StubSurface::configure(MirSurfaceAttrib /*attrib*/, int value)
+int mtd::StubSurface::configure(MirWindowAttrib /*attrib*/, int value)
 {
     return value;
 }
 
-int mtd::StubSurface::query(MirSurfaceAttrib /*attrib*/) const
+int mtd::StubSurface::query(MirWindowAttrib /*attrib*/) const
 {
     return 0;
 }
 
=== modified file 'tests/mir_test_framework/visible_surface.cpp'
--- tests/mir_test_framework/visible_surface.cpp	2017-01-09 06:48:47 +0000
+++ tests/mir_test_framework/visible_surface.cpp	2017-01-10 20:52:04 +0000
@@ -42,12 +42,13 @@
 
 void mtf::VisibleSurface::event_callback(MirSurface* surf, MirEvent const* ev, void* context)
 {
-    if (mir_event_get_type(ev) == mir_event_type_surface)
+    if (mir_event_get_type(ev) == mir_event_type_window)
     {
-        if (mir_surface_event_get_attribute(mir_event_get_surface_event(ev)) == mir_surface_attrib_visibility)
+        auto attrib = mir_window_event_get_attribute(mir_event_get_window_event(ev));
+        if (attrib == mir_window_attrib_visibility)
         {
             auto ctx = reinterpret_cast<VisibleSurface*>(context);
-            ctx->set_visibility(surf, mir_surface_event_get_attribute_value(mir_event_get_surface_event(ev)));
+            ctx->set_visibility(surf, mir_window_event_get_attribute_value(mir_event_get_window_event(ev)));
         }
     }
 }
 
=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
--- tests/unit-tests/client/test_client_mir_surface.cpp	2017-01-09 06:48:47 +0000
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2017-01-10 20:52:04 +0000
@@ -210,13 +210,13 @@
 };
 
 std::map<int, int> MockServerPackageGenerator::sent_surface_attributes = {
-    { mir_surface_attrib_type, mir_surface_type_normal },
-    { mir_surface_attrib_state, mir_surface_state_restored },
-    { mir_surface_attrib_swapinterval, 1 },
-    { mir_surface_attrib_focus, mir_surface_focused },
-    { mir_surface_attrib_dpi, 19 },
-    { mir_surface_attrib_visibility, mir_surface_visibility_exposed },
-    { mir_surface_attrib_preferred_orientation, mir_orientation_mode_any }
+    { mir_window_attrib_type, mir_window_type_normal },
+    { mir_window_attrib_state, mir_surface_state_restored },
+    { mir_window_attrib_swapinterval, 1 },
+    { mir_window_attrib_focus, mir_surface_focused },
+    { mir_window_attrib_dpi, 19 },
+    { mir_window_attrib_visibility, mir_surface_visibility_exposed },
+    { mir_window_attrib_preferred_orientation, mir_orientation_mode_any }
 };
 
 struct StubClientInputPlatform : public mircv::InputPlatform
@@ -389,9 +389,9 @@
 
     auto surface = create_and_wait_for_surface_with(*client_comm_channel);
     
-    for (int i = 0; i < mir_surface_attribs; i++)
+    for (int i = 0; i < mir_window_attribs; i++)
     {
-        EXPECT_EQ(MockServerPackageGenerator::sent_surface_attributes[i], surface->attrib(static_cast<MirSurfaceAttrib>(i)));
+        EXPECT_EQ(MockServerPackageGenerator::sent_surface_attributes[i], surface->attrib(static_cast<MirWindowAttrib>(i)));
     }
 }
 
@@ -492,7 +492,7 @@
 
     auto const surface = create_surface_with(unresponsive_server);
 
-    auto configure_wait_handle = surface->configure(mir_surface_attrib_dpi, 100);
+    auto configure_wait_handle = surface->configure(mir_window_attrib_dpi, 100);
 
     auto expected_end = std::chrono::steady_clock::now() + pause_time;
     configure_wait_handle->wait_for_pending(pause_time);
 
=== modified file 'tests/unit-tests/frontend/test_event_sender.cpp'
--- tests/unit-tests/frontend/test_event_sender.cpp	2016-12-20 15:01:43 +0000
+++ tests/unit-tests/frontend/test_event_sender.cpp	2017-01-10 20:52:04 +0000
@@ -156,7 +156,7 @@
 {
     using namespace testing;
 
-    auto surface_ev = mev::make_event(mf::SurfaceId{1}, mir_surface_attrib_focus, mir_surface_focused);
+    auto surface_ev = mev::make_event(mf::SurfaceId{1}, mir_window_attrib_focus, mir_surface_focused);
     auto resize_ev = mev::make_event(mf::SurfaceId{1}, {10, 10});
 
     EXPECT_CALL(mock_msg_sender, send(_, _, _))
 
=== modified file 'tests/unit-tests/platforms/android/client/test_egl_native_surface_interpreter.cpp'
--- tests/unit-tests/platforms/android/client/test_egl_native_surface_interpreter.cpp	2017-01-09 06:48:47 +0000
+++ tests/unit-tests/platforms/android/client/test_egl_native_surface_interpreter.cpp	2017-01-10 20:52:04 +0000
@@ -57,7 +57,7 @@
     MOCK_CONST_METHOD0(get_parameters, MirWindowParameters());
     MOCK_METHOD0(get_current_buffer, std::shared_ptr<mcl::ClientBuffer>());
     MOCK_METHOD0(swap_buffers_sync, void());
-    MOCK_METHOD2(request_and_wait_for_configure, void(MirSurfaceAttrib, int));
+    MOCK_METHOD2(request_and_wait_for_configure, void(MirWindowAttrib, int));
     MOCK_METHOD1(set_buffer_cache_size, void(unsigned int));
     MirWindowParameters params;
     std::shared_ptr<mtd::MockClientBuffer> client_buffer;
@@ -223,8 +223,8 @@
 {
     testing::NiceMock<MockMirSurface> mock_surface{surf_params};
     testing::InSequence seq;
-    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_surface_attrib_swapinterval, 1));
-    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_surface_attrib_swapinterval, 0));
+    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_window_attrib_swapinterval, 1));
+    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_window_attrib_swapinterval, 0));
 
     mcla::EGLNativeSurfaceInterpreter interpreter(mock_surface);
     interpreter.sync_to_display(true); 
 
=== modified file 'tests/unit-tests/platforms/mesa/client/test_native_surface.cpp'
--- tests/unit-tests/platforms/mesa/client/test_native_surface.cpp	2017-01-09 06:48:47 +0000
+++ tests/unit-tests/platforms/mesa/client/test_native_surface.cpp	2017-01-10 20:52:04 +0000
@@ -105,9 +105,9 @@
     using namespace testing;
 
     Sequence seq;
-    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_surface_attrib_swapinterval,0))
+    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_window_attrib_swapinterval,0))
         .InSequence(seq);
-    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_surface_attrib_swapinterval,1))
+    EXPECT_CALL(mock_surface, request_and_wait_for_configure(mir_window_attrib_swapinterval,1))
         .InSequence(seq);
 
     EXPECT_EQ(MIR_MESA_TRUE, native_surface.set_swapinterval(0));
 
=== modified file 'tests/unit-tests/scene/test_abstract_shell.cpp'
--- tests/unit-tests/scene/test_abstract_shell.cpp	2016-11-09 02:30:14 +0000
+++ tests/unit-tests/scene/test_abstract_shell.cpp	2017-01-10 20:52:04 +0000
@@ -384,13 +384,13 @@
 
     MirSurfaceState const state{mir_surface_state_fullscreen};
 
-    EXPECT_CALL(*wm, set_surface_attribute(session, surface, mir_surface_attrib_state, state))
+    EXPECT_CALL(*wm, set_surface_attribute(session, surface, mir_window_attrib_state, state))
         .WillOnce(WithArg<1>(Invoke([](std::shared_ptr<ms::Surface> const& surface)
-             { surface->configure(mir_surface_attrib_state, mir_surface_state_maximized); return mir_surface_state_maximized; })));
-
-    EXPECT_CALL(mock_surface, configure(mir_surface_attrib_state, mir_surface_state_maximized));
-
-    shell.set_surface_attribute(session, surface, mir_surface_attrib_state, mir_surface_state_fullscreen);
+             { surface->configure(mir_window_attrib_state, mir_surface_state_maximized); return mir_surface_state_maximized; })));
+
+    EXPECT_CALL(mock_surface, configure(mir_window_attrib_state, mir_surface_state_maximized));
+
+    shell.set_surface_attribute(session, surface, mir_window_attrib_state, mir_surface_state_fullscreen);
 }
 
 TEST_F(AbstractShell, as_focus_controller_set_focus_to_notifies_session_event_sink)
 
=== modified file 'tests/unit-tests/scene/test_application_session.cpp'
--- tests/unit-tests/scene/test_application_session.cpp	2016-11-11 07:56:09 +0000
+++ tests/unit-tests/scene/test_application_session.cpp	2017-01-10 20:52:04 +0000
@@ -114,7 +114,7 @@
 
 MATCHER(IsSurfaceOutputEvent, "")
 {
-    return mir_event_get_type(&arg) == mir_event_type_surface_output;
+    return mir_event_get_type(&arg) == mir_event_type_window_output;
 }
 
 struct StubSurfaceStack : public msh::SurfaceStack
@@ -696,7 +696,7 @@
 
     ms::SurfaceCreationParameters params = ms::SurfaceCreationParameters{}
         .of_name("Aardavks")
-        .of_type(mir_surface_type_normal)
+        .of_type(mir_window_type_normal)
         .with_buffer_stream(id);
 
     session->create_surface(params, event_sink);
@@ -895,13 +895,13 @@
 {
     using namespace testing;
 
-    if (mir_event_get_type(arg) != mir_event_type_surface_output)
+    if (mir_event_get_type(arg) != mir_event_type_window_output)
     {
-        *result_listener << "Event is not a MirSurfaceOutputEvent";
+        *result_listener << "Event is not a MirWindowOutputEvent";
         return 0;
     }
 
-    auto const event = mir_event_get_surface_output_event(arg);
+    auto const event = mir_event_get_window_output_event(arg);
 
     if (output.output.current_mode_index >= output.output.modes.size())
         return false;
@@ -911,23 +911,23 @@
     return
         ExplainMatchResult(
             Eq(output.dpi),
-            mir_surface_output_event_get_dpi(event),
+            mir_window_output_event_get_dpi(event),
             result_listener) &&
         ExplainMatchResult(
             Eq(output.form_factor),
-            mir_surface_output_event_get_form_factor(event),
+            mir_window_output_event_get_form_factor(event),
             result_listener) &&
         ExplainMatchResult(
             Eq(output.scale),
-            mir_surface_output_event_get_scale(event),
+            mir_window_output_event_get_scale(event),
             result_listener) &&
         ExplainMatchResult(
             Eq(mode.vrefresh_hz),
-            mir_surface_output_event_get_refresh_rate(event),
+            mir_window_output_event_get_refresh_rate(event),
             result_listener) &&
         ExplainMatchResult(
             Eq(output.id),
-            mir_surface_output_event_get_output_id(event),
+            mir_window_output_event_get_output_id(event),
             result_listener);
 }
 }
@@ -942,7 +942,7 @@
     EXPECT_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
         .WillOnce(Invoke([&event, &event_received](MirEvent const& ev)
                          {
-                             if (event.type() == mir_event_type_surface_output)
+                             if (event.type() == mir_event_type_window_output)
                              {
                                  event = *ev.to_surface_output();
                              }
@@ -978,7 +978,7 @@
     ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
         .WillByDefault(Invoke([&event, &events_received](MirEvent const& ev)
                          {
-                             if (ev.type() == mir_event_type_surface_output)
+                             if (ev.type() == mir_event_type_window_output)
                              {
                                  event[events_received] = *ev.to_surface_output();
                              }
@@ -1035,7 +1035,7 @@
     ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
         .WillByDefault(Invoke([&event, &event_received](MirEvent const& ev)
                               {
-                                  if (ev.type() == mir_event_type_surface_output)
+                                  if (ev.type() == mir_event_type_window_output)
                                   {
                                       event = *ev.to_surface_output();
                                   }
@@ -1083,7 +1083,7 @@
     ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
         .WillByDefault(Invoke([&event, &event_received](MirEvent const& ev)
                               {
-                                  if (ev.type() == mir_event_type_surface_output)
+                                  if (ev.type() == mir_event_type_window_output)
                                   {
                                       event = *ev.to_surface_output();
                                   }
@@ -1144,7 +1144,7 @@
     ON_CALL(*sender, handle_event(IsSurfaceOutputEvent()))
         .WillByDefault(Invoke([&event, &events_received](MirEvent const& ev)
                               {
-                                  if (ev.type() == mir_event_type_surface_output)
+                                  if (ev.type() == mir_event_type_window_output)
                                   {
                                       event = *ev.to_surface_output();
                                   }
 
=== modified file 'tests/unit-tests/scene/test_basic_surface.cpp'
--- tests/unit-tests/scene/test_basic_surface.cpp	2016-11-09 02:30:14 +0000
+++ tests/unit-tests/scene/test_basic_surface.cpp	2017-01-10 20:52:04 +0000
@@ -64,7 +64,7 @@
 class MockSurfaceObserver : public ms::NullSurfaceObserver
 {
 public:
-    MOCK_METHOD2(attrib_changed, void(MirSurfaceAttrib, int));
+    MOCK_METHOD2(attrib_changed, void(MirWindowAttrib, int));
     MOCK_METHOD1(hidden_set_to, void(bool));
     MOCK_METHOD1(renamed, void(char const*));
     MOCK_METHOD0(client_surface_close_requested, void());
@@ -508,7 +508,7 @@
 
 struct AttributeTestParameters
 {
-    MirSurfaceAttrib attribute;
+    MirWindowAttrib attribute;
     int default_value;
     int a_valid_value;
     int an_invalid_value;
@@ -520,42 +520,42 @@
 };
 
 AttributeTestParameters const surface_visibility_test_parameters{
-    mir_surface_attrib_visibility,
+    mir_window_attrib_visibility,
     mir_surface_visibility_occluded,
     mir_surface_visibility_exposed,
     -1
 };
 
 AttributeTestParameters const surface_type_test_parameters{
-    mir_surface_attrib_type,
-    mir_surface_type_normal,
-    mir_surface_type_freestyle,
+    mir_window_attrib_type,
+    mir_window_type_normal,
+    mir_window_type_freestyle,
     -1
 };
 
 AttributeTestParameters const surface_state_test_parameters{
-    mir_surface_attrib_state,
+    mir_window_attrib_state,
     mir_surface_state_restored,
     mir_surface_state_fullscreen,
     1178312
 };
 
 AttributeTestParameters const surface_swapinterval_test_parameters{
-    mir_surface_attrib_swapinterval,
+    mir_window_attrib_swapinterval,
     1,
     0,
     -1
 };
 
 AttributeTestParameters const surface_dpi_test_parameters{
-    mir_surface_attrib_dpi,
+    mir_window_attrib_dpi,
     0,
     90,
     -1
 };
 
 AttributeTestParameters const surface_focus_test_parameters{
-    mir_surface_attrib_focus,
+    mir_window_attrib_focus,
     mir_surface_unfocused,
     mir_surface_focused,
     -1
@@ -920,9 +920,9 @@
     EXPECT_CALL(*buffer_stream, drop_old_buffers()).Times(Exactly(1));
     EXPECT_CALL(*mock_buffer_stream, drop_old_buffers()).Times(Exactly(1));
 
-    surface.configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded);
-    surface.configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed);
-    surface.configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed);
+    surface.configure(mir_window_attrib_visibility, mir_surface_visibility_occluded);
+    surface.configure(mir_window_attrib_visibility, mir_surface_visibility_exposed);
+    surface.configure(mir_window_attrib_visibility, mir_surface_visibility_exposed);
 }
 
 //TODO: per-stream alpha and swapinterval seems useful
@@ -988,7 +988,7 @@
     EXPECT_CALL(*buffer_stream, allow_framedropping(true));
 
     surface.set_streams(streams);
-    surface.configure(mir_surface_attrib_swapinterval, 0);
+    surface.configure(mir_window_attrib_swapinterval, 0);
 }
 
 TEST_F(BasicSurfaceTest, visibility_matches_produced_list)
@@ -1102,9 +1102,9 @@
 {
 struct VisibilityObserver : ms::NullSurfaceObserver
 {
-    void attrib_changed(MirSurfaceAttrib attrib, int value) override
+    void attrib_changed(MirWindowAttrib attrib, int value) override
     {
-        if (attrib == mir_surface_attrib_visibility)
+        if (attrib == mir_window_attrib_visibility)
         {
             if (value == mir_surface_visibility_occluded)
                 hides_++;
@@ -1134,7 +1134,7 @@
 
     EXPECT_THAT(observer->exposes(), Eq(0));
     EXPECT_THAT(observer->hides(), Eq(0));
-    surface.configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed);
+    surface.configure(mir_window_attrib_visibility, mir_surface_visibility_exposed);
 
     EXPECT_THAT(observer->exposes(), Eq(1));
     EXPECT_THAT(observer->hides(), Eq(0));
 
=== modified file 'tests/unit-tests/scene/test_rendering_tracker.cpp'
--- tests/unit-tests/scene/test_rendering_tracker.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/scene/test_rendering_tracker.cpp	2017-01-10 20:52:04 +0000
@@ -48,7 +48,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded));
+        configure(mir_window_attrib_visibility, mir_surface_visibility_occluded));
 
     tracker.active_compositors(compositors);
 
@@ -63,7 +63,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed));
+        configure(mir_window_attrib_visibility, mir_surface_visibility_exposed));
 
     tracker.active_compositors(compositors);
 
@@ -78,7 +78,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed));
+        configure(mir_window_attrib_visibility, mir_surface_visibility_exposed));
 
     tracker.active_compositors(compositors);
 
@@ -94,7 +94,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded))
+        configure(mir_window_attrib_visibility, mir_surface_visibility_occluded))
         .Times(0);
 
     tracker.active_compositors(compositors);
@@ -111,7 +111,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded));
+        configure(mir_window_attrib_visibility, mir_surface_visibility_occluded));
 
     tracker.active_compositors(compositors);
 
@@ -136,7 +136,7 @@
 
     EXPECT_CALL(
         *mock_surface,
-        configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded));
+        configure(mir_window_attrib_visibility, mir_surface_visibility_occluded));
 
     compositors.erase(compositor_id3);
     tracker.active_compositors(compositors);
 
=== modified file 'tests/unit-tests/scene/test_surface.cpp'
--- tests/unit-tests/scene/test_surface.cpp	2016-11-11 06:59:42 +0000
+++ tests/unit-tests/scene/test_surface.cpp	2017-01-10 20:52:04 +0000
@@ -93,7 +93,7 @@
     MirPixelFormat const format{mir_pixel_format_abgr_8888};
     std::string name{"surface"};
     MirSurfaceState state{mir_surface_state_fullscreen};
-    MirSurfaceType type{mir_surface_type_dialog};
+    MirWindowType type{mir_window_type_dialog};
     MirOrientationMode mode{mir_orientation_mode_landscape};
     mf::SurfaceId surf_id{1000};
 
 
=== modified file 'tests/unit-tests/scene/test_surface_impl.cpp'
--- tests/unit-tests/scene/test_surface_impl.cpp	2016-11-11 06:59:42 +0000
+++ tests/unit-tests/scene/test_surface_impl.cpp	2017-01-10 20:52:04 +0000
@@ -102,7 +102,7 @@
     using namespace testing;
 
     EXPECT_THROW({
-        surface->configure(static_cast<MirSurfaceAttrib>(111), 222);
+        surface->configure(static_cast<MirWindowAttrib>(111), 222);
     }, std::logic_error);
 }
 
@@ -110,30 +110,30 @@
 {
     using namespace testing;
 
-    EXPECT_EQ(mir_surface_type_normal, surface->type());
-
-    EXPECT_EQ(mir_surface_type_utility,
-              surface->configure(mir_surface_attrib_type,
-                             mir_surface_type_utility));
-    EXPECT_EQ(mir_surface_type_utility, surface->type());
-
-    EXPECT_THROW({
-        surface->configure(mir_surface_attrib_type, 999);
-    }, std::logic_error);
-    EXPECT_THROW({
-        surface->configure(mir_surface_attrib_type, -1);
-    }, std::logic_error);
-    EXPECT_EQ(mir_surface_type_utility, surface->type());
-
-    EXPECT_EQ(mir_surface_type_dialog,
-              surface->configure(mir_surface_attrib_type,
-                             mir_surface_type_dialog));
-    EXPECT_EQ(mir_surface_type_dialog, surface->type());
-
-    EXPECT_EQ(mir_surface_type_freestyle,
-              surface->configure(mir_surface_attrib_type,
-                             mir_surface_type_freestyle));
-    EXPECT_EQ(mir_surface_type_freestyle, surface->type());
+    EXPECT_EQ(mir_window_type_normal, surface->type());
+
+    EXPECT_EQ(mir_window_type_utility,
+              surface->configure(mir_window_attrib_type,
+                             mir_window_type_utility));
+    EXPECT_EQ(mir_window_type_utility, surface->type());
+
+    EXPECT_THROW({
+        surface->configure(mir_window_attrib_type, 999);
+    }, std::logic_error);
+    EXPECT_THROW({
+        surface->configure(mir_window_attrib_type, -1);
+    }, std::logic_error);
+    EXPECT_EQ(mir_window_type_utility, surface->type());
+
+    EXPECT_EQ(mir_window_type_dialog,
+              surface->configure(mir_window_attrib_type,
+                             mir_window_type_dialog));
+    EXPECT_EQ(mir_window_type_dialog, surface->type());
+
+    EXPECT_EQ(mir_window_type_freestyle,
+              surface->configure(mir_window_attrib_type,
+                             mir_window_type_freestyle));
+    EXPECT_EQ(mir_window_type_freestyle, surface->type());
 }
 
 TEST_F(Surface, states)
@@ -143,25 +143,25 @@
     EXPECT_EQ(mir_surface_state_restored, surface->state());
 
     EXPECT_EQ(mir_surface_state_vertmaximized,
-              surface->configure(mir_surface_attrib_state,
+              surface->configure(mir_window_attrib_state,
                              mir_surface_state_vertmaximized));
     EXPECT_EQ(mir_surface_state_vertmaximized, surface->state());
 
     EXPECT_THROW({
-        surface->configure(mir_surface_attrib_state, 999);
+        surface->configure(mir_window_attrib_state, 999);
     }, std::logic_error);
     EXPECT_THROW({
-        surface->configure(mir_surface_attrib_state, -1);
+        surface->configure(mir_window_attrib_state, -1);
     }, std::logic_error);
     EXPECT_EQ(mir_surface_state_vertmaximized, surface->state());
 
     EXPECT_EQ(mir_surface_state_minimized,
-              surface->configure(mir_surface_attrib_state,
+              surface->configure(mir_window_attrib_state,
                              mir_surface_state_minimized));
     EXPECT_EQ(mir_surface_state_minimized, surface->state());
 
     EXPECT_EQ(mir_surface_state_fullscreen,
-              surface->configure(mir_surface_attrib_state,
+              surface->configure(mir_window_attrib_state,
                              mir_surface_state_fullscreen));
     EXPECT_EQ(mir_surface_state_fullscreen, surface->state());
 }
@@ -235,9 +235,9 @@
 
     {
         InSequence seq;
-        EXPECT_CALL(sink, handle_event(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_focused)))
+        EXPECT_CALL(sink, handle_event(mt::WindowEvent(mir_window_attrib_focus, mir_surface_focused)))
             .Times(1);
-        EXPECT_CALL(sink, handle_event(mt::SurfaceEvent(mir_surface_attrib_focus, mir_surface_unfocused)))
+        EXPECT_CALL(sink, handle_event(mt::WindowEvent(mir_window_attrib_focus, mir_surface_unfocused)))
             .Times(1);
     }
 
@@ -246,8 +246,8 @@
 
     surface->add_observer(observer);
 
-    surface->configure(mir_surface_attrib_focus, mir_surface_focused);
-    surface->configure(mir_surface_attrib_focus, mir_surface_unfocused);
+    surface->configure(mir_window_attrib_focus, mir_surface_focused);
+    surface->configure(mir_window_attrib_focus, mir_surface_unfocused);
 }
 MATCHER_P(MirCloseSurfaceEventMatches, event, "")
 {
@@ -286,5 +286,5 @@
         std::shared_ptr<mg::CursorImage>(),
         report);
 
-    EXPECT_EQ(mir_orientation_mode_any, surf.query(mir_surface_attrib_preferred_orientation));
+    EXPECT_EQ(mir_orientation_mode_any, surf.query(mir_window_attrib_preferred_orientation));
 }
 
=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
--- tests/unit-tests/scene/test_surface_stack.cpp	2016-11-16 13:08:55 +0000
+++ tests/unit-tests/scene/test_surface_stack.cpp	2017-01-10 20:52:04 +0000
@@ -281,7 +281,7 @@
         std::shared_ptr<mg::CursorImage>(),
         report);
     stack.add_surface(surface, default_params.input_mode);
-    surface->configure(mir_surface_attrib_visibility,
+    surface->configure(mir_window_attrib_visibility,
                        mir_surface_visibility_exposed);
     
     auto elements = stack.scene_elements_for(compositor_id);
@@ -310,7 +310,7 @@
         std::shared_ptr<mg::CursorImage>(),
         report);
     stack.add_surface(surface, default_params.input_mode);
-    surface->configure(mir_surface_attrib_visibility,
+    surface->configure(mir_window_attrib_visibility,
                        mir_surface_visibility_exposed);
     
     // (change directory in shell app)
@@ -356,7 +356,7 @@
         std::shared_ptr<mg::CursorImage>(),
         report);
     stack.add_surface(surface, default_params.input_mode);
-    surface->configure(mir_surface_attrib_visibility,
+    surface->configure(mir_window_attrib_visibility,
                        mir_surface_visibility_exposed);
 
     EXPECT_EQ(0, stack.frames_pending(this));
@@ -811,7 +811,7 @@
             mir::report::null_scene_report())
     {
     }
-    MOCK_METHOD2(configure, int(MirSurfaceAttrib, int));
+    MOCK_METHOD2(configure, int(MirWindowAttrib, int));
 };
 }
 
@@ -834,7 +834,7 @@
     auto const elements2 = stack.scene_elements_for(compositor_id2);
     ASSERT_THAT(elements2.size(), Eq(1u));
 
-    EXPECT_CALL(*mock_surface, configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded));
+    EXPECT_CALL(*mock_surface, configure(mir_window_attrib_visibility, mir_surface_visibility_occluded));
 
     elements.back()->occluded();
     elements2.back()->occluded();
@@ -857,7 +857,7 @@
     auto const elements2 = stack.scene_elements_for(compositor_id2);
     ASSERT_THAT(elements2.size(), Eq(1u));
 
-    EXPECT_CALL(*mock_surface, configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed));
+    EXPECT_CALL(*mock_surface, configure(mir_window_attrib_visibility, mir_surface_visibility_exposed));
 
     elements.back()->occluded();
     elements2.back()->rendered();
@@ -884,7 +884,7 @@
     auto const elements3 = stack.scene_elements_for(compositor_id3);
     ASSERT_THAT(elements3.size(), Eq(1u));
 
-    EXPECT_CALL(*mock_surface, configure(mir_surface_attrib_visibility, mir_surface_visibility_exposed))
+    EXPECT_CALL(*mock_surface, configure(mir_window_attrib_visibility, mir_surface_visibility_exposed))
         .Times(2);
 
     elements.back()->occluded();
@@ -893,7 +893,7 @@
 
     Mock::VerifyAndClearExpectations(mock_surface.get());
 
-    EXPECT_CALL(*mock_surface, configure(mir_surface_attrib_visibility, mir_surface_visibility_occluded));
+    EXPECT_CALL(*mock_surface, configure(mir_window_attrib_visibility, mir_surface_visibility_occluded));
 
     stack.unregister_compositor(compositor_id2);
     stack.unregister_compositor(compositor_id3);
@@ -978,8 +978,8 @@
     stack.add_surface(stub_surface2, default_params.input_mode);
 
     // Configure surface1 and surface2 to appear in input enumeration.
-    stub_surface1->configure(mir_surface_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
-    stub_surface2->configure(mir_surface_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
+    stub_surface1->configure(mir_window_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
+    stub_surface2->configure(mir_window_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
 
     stack.add_input_visualization(mt::fake_shared(r));
 
@@ -1056,9 +1056,9 @@
     stack.add_surface(stub_surface2, default_params.input_mode);
     stack.add_surface(stub_surface3, default_params.input_mode);
 
-    stub_surface1->configure(mir_surface_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
-    stub_surface2->configure(mir_surface_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_occluded);
-    stub_surface3->configure(mir_surface_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_occluded);
+    stub_surface1->configure(mir_window_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_exposed);
+    stub_surface2->configure(mir_window_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_occluded);
+    stub_surface3->configure(mir_window_attrib_visibility, MirSurfaceVisibility::mir_surface_visibility_occluded);
 
     int num_exposed_surfaces = 0;
     auto const count_exposed_surfaces = [&num_exposed_surfaces](std::shared_ptr<mi::Surface> const&){