Merge lp:~artmello/qtubuntu/qtubuntu-new_mir_api into lp:qtubuntu

[Arthur Mello]

Update code to use new Mir Api's.

Changes:
- Update/Remove deprecated code to fix build issues

Update code to use new Mir Api's.

Changes:
- Update/Remove deprecated code to fix build issues

[Daniel d'Andrada (dandrader)]

Could you please update the copyright header of all modified files to 2017?

[Arthur Mello (artmello)]

> Could you please update the copyright header of all modified files to 2017?

done on rev 375

[Gerry Boland (gerboland)]

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
             auto cursorConfiguration = mir_cursor_configuration_from_name(cursorName.data());
- mir_surface_configure_cursor(surface, cursorConfiguration);
+#pragma GCC diagnostic pop

If we have to work around Mir in this way, then Mir has a problem. Is Mir really missing a non-deprecated API for this?

review: Needs Information

[Gerry Boland (gerboland)]

Ok, tracked this change down to mir rev 3858. Comment says:

"client: deprecate mir_cursor_configuration_from_name and prepare to deprecate mir_surface_configure_cursor, mir_cursor_configuration_destroy, and mir_cursor_configuration_from_buffer_stream once MirRenderSurface is published. The new alternative is to use MirSurfaceSpec based cursor configurations.

The new functions are mir_surface_spec_set_cursor_name and mir_surface_spec_set_cursor_render_surface which set the cursor from the canonical names, or sets a custom cursor via a MirRenderSurface.

This also makes application of cursors something the shell can mediate, like the rest of the surface modifications. (previously it was unable to mediate this)."

[Gerry Boland (gerboland)]

As supporting the new cursor API requires extra work, I'm ok with landing this with the deprecation workaround

review: Abstain

[Arthur Mello (artmello)]

> If we have to work around Mir in this way, then Mir has a problem. Is Mir
> really missing a non-deprecated API for this?

While searching on how to replace mir_cursor_configuration_from_name, I saw that it was possible to use mir_window_spec_set_cursor_name passing a pointer for MirWindowSpec and a name. I was not totally sure on how to get MirWindowSpec from the window on that point. Looking for examples, found the used code here on a mir acceptance-test [0]. But I am totally up to change it and do not use this workaround.

[0] http://bazaar.launchpad.net/~mir-team/mir/development-branch/view/head:/tests/acceptance-tests/test_client_cursor_api.cpp#L223

[Daniel d'Andrada (dandrader)]

"""
Qt::WindowState mirWindowStateToWindowState(MirWindowState state)
"""

With the s/Surface/Window that name got confusing and repetitive. Could you please name it like this instead?

mirWindowStateToQt

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

In makeSurfaceSpec (src/ubuntumirclient/qmirclientwindow.cpp) you're no longer applying the specified pixel format.

To do so, add this call after the switch (type) {}:

mir_window_spec_set_pixel_format(spec.get(), pixelFormat);

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> In makeSurfaceSpec (src/ubuntumirclient/qmirclientwindow.cpp) you're no longer
> applying the specified pixel format.
>
> To do so, add this call after the switch (type) {}:
>
> mir_window_spec_set_pixel_format(spec.get(), pixelFormat);

And then remove this code:

"""
#if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
    Q_UNUSED(pixelFormat);
#endif
"""

[Daniel d'Andrada (dandrader)]

In several headers you're replacing a forward declaration with a #include.

"""
- struct MirSurface;
"""

"""
+ #include <mir_toolkit/mir_window.h>
"""

Please maintain the forward declaration style. It makes the header files more lightweight.

[Arthur Mello (artmello)]

> """
> Qt::WindowState mirWindowStateToWindowState(MirWindowState state)
> """
>
> With the s/Surface/Window that name got confusing and repetitive. Could you
> please name it like this instead?
>
> mirWindowStateToQt

done (r377)

[Arthur Mello (artmello)]

> > In makeSurfaceSpec (src/ubuntumirclient/qmirclientwindow.cpp) you're no
> longer
> > applying the specified pixel format.
> >
> > To do so, add this call after the switch (type) {}:
> >
> > mir_window_spec_set_pixel_format(spec.get(), pixelFormat);
>
> And then remove this code:
>
> """
> #if MIR_CLIENT_VERSION >= MIR_VERSION_NUMBER(3, 4, 0)
> Q_UNUSED(pixelFormat);
> #endif
> """

done (r378)

[Daniel d'Andrada (dandrader)]

All good. Thanks

review: Approve

[Alberto Aguirre (albaguirre)]

Here's some more changes to properly use the mir's new extension mechanism (no longer a separate debug library) and the cursor_name api changes:

https://code.launchpad.net/~albaguirre/qtubuntu/more-new-mir-apis

[Lukáš Tinkl (lukas-kde)]

Can you please merge your parent?

Text conflict in src/ubuntumirclient/qmirclientcursor.cpp
Text conflict in src/ubuntumirclient/qmirclientcursor.h
Text conflict in src/ubuntumirclient/qmirclientdebugextension.cpp
Text conflict in src/ubuntumirclient/qmirclientdebugextension.h
Text conflict in src/ubuntumirclient/qmirclientinput.cpp
Text conflict in src/ubuntumirclient/qmirclientinput.h
Text conflict in src/ubuntumirclient/qmirclientnativeinterface.cpp
Text conflict in src/ubuntumirclient/qmirclientnativeinterface.h
Text conflict in src/ubuntumirclient/qmirclientwindow.cpp
Text conflict in src/ubuntumirclient/qmirclientwindow.h
10 conflicts encountered.

2017-02-08 15:54:48,633 ERROR zesty/qtubuntu: Failed to merge https://code.launchpad.net/~artmello/qtubuntu/qtubuntu-new_mir_api

review: Needs Fixing

[Lukáš Tinkl (lukas-kde)]

All good, sorry for the noise, parent has been sorted out.

review: Abstain

=== modified file 'src/ubuntumirclient/qmirclientcursor.cpp'
--- src/ubuntumirclient/qmirclientcursor.cpp	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientcursor.cpp	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2015-2016 Canonical, Ltd.
+** Copyright (C) 2015-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -141,9 +141,9 @@
         return;
     }
 
-    MirSurface *surface = static_cast<QMirClientWindow*>(window->handle())->mirSurface();
+    MirWindow *mirWindow = static_cast<QMirClientWindow*>(window->handle())->mirWindow();
 
-    if (!surface) {
+    if (!mirWindow) {
         return;
     }
 
@@ -151,23 +151,26 @@
     if (windowCursor) {
         qCDebug(mirclientCursor, "changeCursor shape=%s, window=%p", qtCursorShapeToStr(windowCursor->shape()), window);
         if (!windowCursor->pixmap().isNull()) {
-            configureMirCursorWithPixmapQCursor(surface, *windowCursor);
+            configureMirCursorWithPixmapQCursor(mirWindow, *windowCursor);
         } else if (windowCursor->shape() == Qt::BitmapCursor) {
             // TODO: Implement bitmap cursor support
-            applyDefaultCursorConfiguration(surface);
+            applyDefaultCursorConfiguration(mirWindow);
         } else {
             const auto &cursorName = mShapeToCursorName.value(windowCursor->shape(), QByteArray("left_ptr"));
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
             auto cursorConfiguration = mir_cursor_configuration_from_name(cursorName.data());
-            mir_surface_configure_cursor(surface, cursorConfiguration);
+#pragma GCC diagnostic pop
+            mir_window_configure_cursor(mirWindow, cursorConfiguration);
             mir_cursor_configuration_destroy(cursorConfiguration);
         }
     } else {
-        applyDefaultCursorConfiguration(surface);
+        applyDefaultCursorConfiguration(mirWindow);
     }
 
 }
 
-void QMirClientCursor::configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor)
+void QMirClientCursor::configureMirCursorWithPixmapQCursor(MirWindow *window, QCursor &cursor)
 {
     QImage image = cursor.pixmap().toImage();
 
@@ -194,16 +197,19 @@
 
     {
         auto configuration = mir_cursor_configuration_from_buffer_stream(bufferStream, cursor.hotSpot().x(), cursor.hotSpot().y());
-        mir_surface_configure_cursor(surface, configuration);
+        mir_window_configure_cursor(window, configuration);
         mir_cursor_configuration_destroy(configuration);
     }
 
     mir_buffer_stream_release_sync(bufferStream);
 }
 
-void QMirClientCursor::applyDefaultCursorConfiguration(MirSurface *surface)
+void QMirClientCursor::applyDefaultCursorConfiguration(MirWindow *window)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     auto cursorConfiguration = mir_cursor_configuration_from_name("left_ptr");
-    mir_surface_configure_cursor(surface, cursorConfiguration);
+#pragma GCC diagnostic pop
+    mir_window_configure_cursor(window, cursorConfiguration);
     mir_cursor_configuration_destroy(cursorConfiguration);
 }

=== modified file 'src/ubuntumirclient/qmirclientcursor.h'
--- src/ubuntumirclient/qmirclientcursor.h	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientcursor.h	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2015-2016 Canonical, Ltd.
+** Copyright (C) 2015-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -46,8 +46,9 @@
 #include <QMap>
 #include <QByteArray>
 
+#include <mir_toolkit/mir_window.h>
+
 struct MirConnection;
-struct MirSurface;
 
 class QMirClientCursor : public QPlatformCursor
 {
@@ -55,8 +56,8 @@
     QMirClientCursor(MirConnection *connection);
     void changeCursor(QCursor *windowCursor, QWindow *window) override;
 private:
-    void configureMirCursorWithPixmapQCursor(MirSurface *surface, QCursor &cursor);
-    void applyDefaultCursorConfiguration(MirSurface *surface);
+    void configureMirCursorWithPixmapQCursor(MirWindow *window, QCursor &cursor);
+    void applyDefaultCursorConfiguration(MirWindow *window);
     QMap<int, QByteArray> mShapeToCursorName;
     MirConnection *mConnection;
 };

=== modified file 'src/ubuntumirclient/qmirclientdebugextension.cpp'
--- src/ubuntumirclient/qmirclientdebugextension.cpp	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientdebugextension.cpp	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 Canonical, Ltd.
+** Copyright (C) 2016-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -52,7 +52,7 @@
     , m_mapper(nullptr)
 {
     qCDebug(mirclientDebug) << "NOTICE: Loading mirclient-debug-extension";
-    m_mapper = (MapperPrototype) m_mirclientDebug.resolve("mir_debug_surface_coords_to_screen");
+    m_mapper = (MapperPrototype) m_mirclientDebug.resolve("mir_extension_window_coordinate_translation");
 
     if (!m_mirclientDebug.isLoaded()) {
         qCWarning(mirclientDebug) << "ERROR: mirclient-debug-extension failed to load:"
@@ -68,14 +68,14 @@
     return m_mirclientDebug.isLoaded() && m_mapper;
 }
 
-QPoint QMirClientDebugExtension::mapSurfacePointToScreen(MirSurface *surface, const QPoint &point)
+QPoint QMirClientDebugExtension::mapWindowPointToScreen(MirWindow *window, const QPoint &point)
 {
     if (!m_mapper) {
         return point;
     }
 
     QPoint mappedPoint;
-    bool status = m_mapper(surface, point.x(), point.y(), &mappedPoint.rx(), &mappedPoint.ry());
+    bool status = m_mapper(window, point.x(), point.y(), &mappedPoint.rx(), &mappedPoint.ry());
     if (status) {
         return mappedPoint;
     } else {

=== modified file 'src/ubuntumirclient/qmirclientdebugextension.h'
--- src/ubuntumirclient/qmirclientdebugextension.h	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientdebugextension.h	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 Canonical, Ltd.
+** Copyright (C) 2016-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -43,9 +43,10 @@
 
 #include <QPoint>
 #include <QLibrary>
-struct MirSurface;
-
-typedef bool (*MapperPrototype)(MirSurface* surface, int x, int y, int* screenX, int* screenY);
+
+#include <mir_toolkit/mir_window.h>
+
+typedef bool (*MapperPrototype)(MirWindow* window, int x, int y, int* screenX, int* screenY);
 
 
 class QMirClientDebugExtension
@@ -55,7 +56,7 @@
 
     bool isEnabled() const;
 
-    QPoint mapSurfacePointToScreen(MirSurface *, const QPoint &point);
+    QPoint mapWindowPointToScreen(MirWindow *, const QPoint &point);
 
 private:
     QLibrary m_mirclientDebug;

=== modified file 'src/ubuntumirclient/qmirclientinput.cpp'
--- src/ubuntumirclient/qmirclientinput.cpp	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientinput.cpp	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2014-2016 Canonical, Ltd.
+** Copyright (C) 2014-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -167,22 +167,22 @@
     0,                          0
 };
 
-Qt::WindowState mirSurfaceStateToWindowState(MirSurfaceState state)
+Qt::WindowState mirWindowStateToQt(MirWindowState state)
 {
     switch (state) {
-    case mir_surface_state_fullscreen:
+    case mir_window_state_fullscreen:
         return Qt::WindowFullScreen;
-    case mir_surface_state_maximized:
-    case mir_surface_state_vertmaximized:
-    case mir_surface_state_horizmaximized:
+    case mir_window_state_maximized:
+    case mir_window_state_vertmaximized:
+    case mir_window_state_horizmaximized:
         return Qt::WindowMaximized;
-    case mir_surface_state_minimized:
+    case mir_window_state_minimized:
         return Qt::WindowMinimized;
-    case mir_surface_state_hidden:
+    case mir_window_state_hidden:
         // We should be handling this state separately.
         Q_ASSERT(false);
-    case mir_surface_state_restored:
-    case mir_surface_state_unknown:
+    case mir_window_state_restored:
+    case mir_window_state_unknown:
     default:
         return Qt::WindowNoState;
     }
@@ -236,28 +236,28 @@
         return "key";
     case mir_event_type_motion:
         return "motion";
-    case mir_event_type_surface:
-        return "surface";
+    case mir_event_type_window:
+        return "window";
     case mir_event_type_resize:
         return "resize";
     case mir_event_type_prompt_session_state_change:
         return "prompt_session_state_change";
     case mir_event_type_orientation:
         return "orientation";
-    case mir_event_type_close_surface:
-        return "close_surface";
+    case mir_event_type_close_window:
+        return "close_window";
     case mir_event_type_input:
         return "input";
     case mir_event_type_keymap:
         return "keymap";
-    case mir_event_type_input_configuration:
-        return "input_configuration";
-    case mir_event_type_surface_output:
-        return "surface_output";
+    case mir_event_type_window_output:
+        return "window_output";
     case mir_event_type_input_device_state:
         return "input_device_state";
-    case mir_event_type_surface_placement:
-        return "surface_placement";
+    case mir_event_type_window_placement:
+        return "window_placement";
+    default:
+        Q_UNREACHABLE();
     }
     Q_UNREACHABLE();
 }
@@ -310,16 +310,16 @@
         }
         break;
     }
-    case mir_event_type_surface:
-        handleSurfaceEvent(ubuntuEvent->window, mir_event_get_surface_event(nativeEvent));
+    case mir_event_type_window:
+        handleWindowEvent(ubuntuEvent->window, mir_event_get_window_event(nativeEvent));
         break;
-    case mir_event_type_surface_output:
-        handleSurfaceOutputEvent(ubuntuEvent->window, mir_event_get_surface_output_event(nativeEvent));
+    case mir_event_type_window_output:
+        handleWindowOutputEvent(ubuntuEvent->window, mir_event_get_window_output_event(nativeEvent));
         break;
     case mir_event_type_orientation:
         dispatchOrientationEvent(ubuntuEvent->window->window(), mir_event_get_orientation_event(nativeEvent));
         break;
-    case mir_event_type_close_surface:
+    case mir_event_type_close_window:
         QWindowSystemInterface::handleCloseEvent(ubuntuEvent->window->window());
         break;
     default:
@@ -618,49 +618,49 @@
                                 new OrientationChangeEvent(OrientationChangeEvent::mType, orientation));
 }
 
-void QMirClientInput::handleSurfaceEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceEvent *event)
+void QMirClientInput::handleWindowEvent(const QPointer<QMirClientWindow> &window, const MirWindowEvent *event)
 {
-    auto surfaceEventAttribute = mir_surface_event_get_attribute(event);
+    auto windowEventAttribute = mir_window_event_get_attribute(event);
 
-    switch (surfaceEventAttribute) {
-    case mir_surface_attrib_focus: {
+    switch (windowEventAttribute) {
+    case mir_window_attrib_focus: {
         window->handleSurfaceFocusChanged(
-                    mir_surface_event_get_attribute_value(event) == mir_surface_focused);
+                    mir_window_event_get_attribute_value(event) == mir_window_focus_state_focused);
         break;
     }
-    case mir_surface_attrib_visibility: {
+    case mir_window_attrib_visibility: {
         window->handleSurfaceExposeChange(
-                    mir_surface_event_get_attribute_value(event) == mir_surface_visibility_exposed);
+                    mir_window_event_get_attribute_value(event) == mir_window_visibility_exposed);
         break;
     }
     // Remaining attributes are ones client sets for server, and server should not override them
-    case mir_surface_attrib_state: {
-        MirSurfaceState state = static_cast<MirSurfaceState>(mir_surface_event_get_attribute_value(event));
+    case mir_window_attrib_state: {
+        MirWindowState state = static_cast<MirWindowState>(mir_window_event_get_attribute_value(event));
 
-        if (state == mir_surface_state_hidden) {
+        if (state == mir_window_state_hidden) {
             window->handleSurfaceVisibilityChanged(false);
         } else {
             // it's visible!
             window->handleSurfaceVisibilityChanged(true);
-            window->handleSurfaceStateChanged(mirSurfaceStateToWindowState(state));
+            window->handleSurfaceStateChanged(mirWindowStateToQt(state));
         }
         break;
     }
-    case mir_surface_attrib_type:
-    case mir_surface_attrib_swapinterval:
-    case mir_surface_attrib_dpi:
-    case mir_surface_attrib_preferred_orientation:
-    case mir_surface_attribs:
+    case mir_window_attrib_type:
+    case mir_window_attrib_swapinterval:
+    case mir_window_attrib_dpi:
+    case mir_window_attrib_preferred_orientation:
+    case mir_window_attribs:
         break;
     }
 }
 
-void QMirClientInput::handleSurfaceOutputEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceOutputEvent *event)
+void QMirClientInput::handleWindowOutputEvent(const QPointer<QMirClientWindow> &window, const MirWindowOutputEvent *event)
 {
-    const uint32_t outputId = mir_surface_output_event_get_output_id(event);
-    const int dpi = mir_surface_output_event_get_dpi(event);
-    const MirFormFactor formFactor = mir_surface_output_event_get_form_factor(event);
-    const float scale = mir_surface_output_event_get_scale(event);
+    const uint32_t outputId = mir_window_output_event_get_output_id(event);
+    const int dpi = mir_window_output_event_get_dpi(event);
+    const MirFormFactor formFactor = mir_window_output_event_get_form_factor(event);
+    const float scale = mir_window_output_event_get_scale(event);
 
     const auto screenObserver = mIntegration->screenObserver();
     QMirClientScreen *screen = screenObserver->findScreenWithId(outputId);

=== modified file 'src/ubuntumirclient/qmirclientinput.h'
--- src/ubuntumirclient/qmirclientinput.h	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientinput.h	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2014-2016 Canonical, Ltd.
+** Copyright (C) 2014-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -71,8 +71,8 @@
     void dispatchInputEvent(QMirClientWindow *window, const MirInputEvent *event);
 
     void dispatchOrientationEvent(QWindow* window, const MirOrientationEvent *event);
-    void handleSurfaceEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceEvent *event);
-    void handleSurfaceOutputEvent(const QPointer<QMirClientWindow> &window, const MirSurfaceOutputEvent *event);
+    void handleWindowEvent(const QPointer<QMirClientWindow> &window, const MirWindowEvent *event);
+    void handleWindowOutputEvent(const QPointer<QMirClientWindow> &window, const MirWindowOutputEvent *event);
 
 private:
     QMirClientClientIntegration* mIntegration;

=== modified file 'src/ubuntumirclient/qmirclientnativeinterface.cpp'
--- src/ubuntumirclient/qmirclientnativeinterface.cpp	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientnativeinterface.cpp	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 Canonical, Ltd.
+** Copyright (C) 2016-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -60,7 +60,7 @@
         insert("nativeorientation", QMirClientNativeInterface::NativeOrientation);
         insert("display", QMirClientNativeInterface::Display);
         insert("mirconnection", QMirClientNativeInterface::MirConnection);
-        insert("mirsurface", QMirClientNativeInterface::MirSurface);
+        insert("mirwindow", QMirClientNativeInterface::MirWindow);
         insert("scale", QMirClientNativeInterface::Scale);
         insert("formfactor", QMirClientNativeInterface::FormFactor);
     }
@@ -137,11 +137,11 @@
             mNativeOrientation = new Qt::ScreenOrientation(platformScreen->nativeOrientation());
         }
         return mNativeOrientation;
-    case MirSurface:
+    case MirWindow:
         if (window) {
             auto ubuntuWindow = static_cast<QMirClientWindow*>(window->handle());
             if (ubuntuWindow) {
-                return ubuntuWindow->mirSurface();
+                return ubuntuWindow->mirWindow();
             } else {
                 return nullptr;
             }

=== modified file 'src/ubuntumirclient/qmirclientnativeinterface.h'
--- src/ubuntumirclient/qmirclientnativeinterface.h	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientnativeinterface.h	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 Canonical, Ltd.
+** Copyright (C) 2016-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -50,7 +50,7 @@
 class QMirClientNativeInterface : public QPlatformNativeInterface {
     Q_OBJECT
 public:
-    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection, MirSurface, Scale, FormFactor };
+    enum ResourceType { EglDisplay, EglContext, NativeOrientation, Display, MirConnection, MirWindow, Scale, FormFactor };
 
     QMirClientNativeInterface(const QMirClientClientIntegration *integration);
     ~QMirClientNativeInterface();

=== modified file 'src/ubuntumirclient/qmirclientwindow.cpp'
--- src/ubuntumirclient/qmirclientwindow.cpp	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientwindow.cpp	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2014-2016 Canonical, Ltd.
+** Copyright (C) 2014-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -84,14 +84,14 @@
 
 struct MirSpecDeleter
 {
-    void operator()(MirSurfaceSpec *spec) { mir_surface_spec_release(spec); }
+    void operator()(MirWindowSpec *spec) { mir_window_spec_release(spec); }
 };
 
-using Spec = std::unique_ptr<MirSurfaceSpec, MirSpecDeleter>;
+using Spec = std::unique_ptr<MirWindowSpec, MirSpecDeleter>;
 
-EGLNativeWindowType nativeWindowFor(MirSurface *surf)
+EGLNativeWindowType nativeWindowFor(MirWindow *surf)
 {
-    auto stream = mir_surface_get_buffer_stream(surf);
+    auto stream = mir_window_get_buffer_stream(surf);
     return reinterpret_cast<EGLNativeWindowType>(mir_buffer_stream_get_egl_native_window(stream));
 }
 
@@ -112,18 +112,18 @@
     Q_UNREACHABLE();
 }
 
-const char *mirSurfaceStateToStr(MirSurfaceState surfaceState)
+const char *mirWindowStateToStr(MirWindowState windowState)
 {
-    switch (surfaceState) {
-    case mir_surface_state_unknown: return "unknown";
-    case mir_surface_state_restored: return "restored";
-    case mir_surface_state_minimized: return "minimized";
-    case mir_surface_state_maximized: return "vertmaximized";
-    case mir_surface_state_vertmaximized: return "vertmaximized";
-    case mir_surface_state_fullscreen: return "fullscreen";
-    case mir_surface_state_horizmaximized: return "horizmaximized";
-    case mir_surface_state_hidden: return "hidden";
-    case mir_surface_states: Q_UNREACHABLE();
+    switch (windowState) {
+    case mir_window_state_unknown: return "unknown";
+    case mir_window_state_restored: return "restored";
+    case mir_window_state_minimized: return "minimized";
+    case mir_window_state_maximized: return "vertmaximized";
+    case mir_window_state_vertmaximized: return "vertmaximized";
+    case mir_window_state_fullscreen: return "fullscreen";
+    case mir_window_state_horizmaximized: return "horizmaximized";
+    case mir_window_state_hidden: return "hidden";
+    case mir_window_states: Q_UNREACHABLE();
     }
     Q_UNREACHABLE();
 }
@@ -146,57 +146,57 @@
     Q_UNREACHABLE();
 }
 
-const char *mirSurfaceTypeToStr(MirSurfaceType type)
+const char *mirWindowTypeToStr(MirWindowType type)
 {
     switch (type) {
-    case mir_surface_type_normal:       return "Normal";        /**< AKA "regular"                   */
-    case mir_surface_type_utility:      return "Utility";       /**< AKA "floating regular"          */
-    case mir_surface_type_dialog:       return "Dialog";
-    case mir_surface_type_gloss:        return "Gloss";
-    case mir_surface_type_freestyle:    return "Freestyle";
-    case mir_surface_type_menu:         return "Menu";
-    case mir_surface_type_inputmethod:  return "Input Method";  /**< AKA "OSK" or handwriting etc.   */
-    case mir_surface_type_satellite:    return "Satellite";     /**< AKA "toolbox"/"toolbar"         */
-    case mir_surface_type_tip:          return "Tip";           /**< AKA "tooltip"                   */
-    case mir_surface_types:             Q_UNREACHABLE();
+    case mir_window_type_normal:       return "Normal";        /**< AKA "regular"                   */
+    case mir_window_type_utility:      return "Utility";       /**< AKA "floating regular"          */
+    case mir_window_type_dialog:       return "Dialog";
+    case mir_window_type_gloss:        return "Gloss";
+    case mir_window_type_freestyle:    return "Freestyle";
+    case mir_window_type_menu:         return "Menu";
+    case mir_window_type_inputmethod:  return "Input Method";  /**< AKA "OSK" or handwriting etc.   */
+    case mir_window_type_satellite:    return "Satellite";     /**< AKA "toolbox"/"toolbar"         */
+    case mir_window_type_tip:          return "Tip";           /**< AKA "tooltip"                   */
+    case mir_window_types:             Q_UNREACHABLE();
     }
     return "";
 }
 
-MirSurfaceState qtWindowStateToMirSurfaceState(Qt::WindowState state)
+MirWindowState qtWindowStateToMirWindowState(Qt::WindowState state)
 {
     switch (state) {
     case Qt::WindowNoState:
     case Qt::WindowActive:
-        return mir_surface_state_restored;
+        return mir_window_state_restored;
     case Qt::WindowFullScreen:
-        return mir_surface_state_fullscreen;
+        return mir_window_state_fullscreen;
     case Qt::WindowMaximized:
-        return mir_surface_state_maximized;
+        return mir_window_state_maximized;
     case Qt::WindowMinimized:
-        return mir_surface_state_minimized;
+        return mir_window_state_minimized;
     }
-    return mir_surface_state_unknown; // should never be reached
+    return mir_window_state_unknown; // should never be reached
 }
 
-MirSurfaceType qtWindowTypeToMirSurfaceType(Qt::WindowType type)
+MirWindowType qtWindowTypeToMirWindowType(Qt::WindowType type)
 {
     switch (type & Qt::WindowType_Mask) {
     case Qt::Dialog:
-        return mir_surface_type_dialog;
+        return mir_window_type_dialog;
     case Qt::Sheet:
     case Qt::Drawer:
-        return mir_surface_type_utility;
+        return mir_window_type_utility;
     case Qt::Popup:
     case Qt::Tool:
-        return mir_surface_type_menu;
+        return mir_window_type_menu;
     case Qt::ToolTip:
-        return mir_surface_type_tip;
+        return mir_window_type_tip;
     case Qt::SplashScreen:
-        return mir_surface_type_freestyle;
+        return mir_window_type_freestyle;
     case Qt::Window:
     default:
-        return mir_surface_type_normal;
+        return mir_window_type_normal;
     }
 }
 
@@ -225,15 +225,15 @@
     return parent ? static_cast<QMirClientWindow *>(parent->handle()) : nullptr;
 }
 
-bool requiresParent(const MirSurfaceType type)
+bool requiresParent(const MirWindowType type)
 {
     switch (type) {
-    case mir_surface_type_dialog: //FIXME - not quite what the specification dictates, but is what Mir's api dictates
-    case mir_surface_type_utility:
-    case mir_surface_type_gloss:
-    case mir_surface_type_menu:
-    case mir_surface_type_satellite:
-    case mir_surface_type_tip:
+    case mir_window_type_dialog: //FIXME - not quite what the specification dictates, but is what Mir's api dictates
+    case mir_window_type_utility:
+    case mir_window_type_gloss:
+    case mir_window_type_menu:
+    case mir_window_type_satellite:
+    case mir_window_type_tip:
         return true;
     default:
         return false;
@@ -242,7 +242,7 @@
 
 bool requiresParent(const Qt::WindowType type)
 {
-    return requiresParent(qtWindowTypeToMirSurfaceType(type));
+    return requiresParent(qtWindowTypeToMirWindowType(type));
 }
 
 Spec makeSurfaceSpec(QWindow *window, MirPixelFormat pixelFormat, QMirClientWindow *parentWindowHandle,
@@ -251,16 +251,16 @@
     const auto geometry = window->geometry();
     const int width = geometry.width() > 0 ? geometry.width() : 1;
     const int height = geometry.height() > 0 ? geometry.height() : 1;
-    auto type = qtWindowTypeToMirSurfaceType(window->type());
+    auto type = qtWindowTypeToMirWindowType(window->type());
 
     if (U_ON_SCREEN_KEYBOARD_ROLE == roleFor(window)) {
-        type = mir_surface_type_inputmethod;
+        type = mir_window_type_inputmethod;
     }
 
     MirRectangle location{geometry.x(), geometry.y(), 0, 0};
-    MirSurface *parent = nullptr;
+    MirWindow *parent = nullptr;
     if (parentWindowHandle) {
-        parent = parentWindowHandle->mirSurface();
+        parent = parentWindowHandle->mirWindow();
         // Qt uses absolute positioning, but Mir positions surfaces relative to parent.
         location.top  -= parentWindowHandle->geometry().top();
         location.left -= parentWindowHandle->geometry().left();
@@ -269,85 +269,87 @@
     Spec spec;
 
     switch (type) {
-    case mir_surface_type_menu:
-        spec = Spec{mir_connection_create_spec_for_menu(connection, width, height, pixelFormat, parent,
+    case mir_window_type_menu:
+        spec = Spec{mir_create_menu_window_spec(connection, width, height, parent,
                     &location, mir_edge_attachment_any)};
         break;
-    case mir_surface_type_dialog:
-        spec = Spec{mir_connection_create_spec_for_modal_dialog(connection, width, height, pixelFormat, parent)};
-        break;
-    case mir_surface_type_utility:
-        spec = Spec{mir_connection_create_spec_for_dialog(connection, width, height, pixelFormat)};
-        break;
-    case mir_surface_type_tip:
+    case mir_window_type_dialog:
+        spec = Spec{mir_create_modal_dialog_window_spec(connection, width, height, parent)};
+        break;
+    case mir_window_type_utility:
+        spec = Spec{mir_create_dialog_window_spec(connection, width, height)};
+        break;
+    case mir_window_type_tip:
 #if MIR_CLIENT_VERSION < MIR_VERSION_NUMBER(3, 4, 0)
         spec = Spec{mir_connection_create_spec_for_tooltip(connection, width, height, pixelFormat, parent,
                     &location)};
 #else
-        spec = Spec{mir_connection_create_spec_for_tip(connection, width, height, pixelFormat, parent,
+        spec = Spec{mir_create_tip_window_spec(connection, width, height, parent,
                     &location, mir_edge_attachment_any)};
 #endif
         break;
-    case mir_surface_type_inputmethod:
-        spec = Spec{mir_connection_create_spec_for_input_method(connection, width, height, pixelFormat)};
+    case mir_window_type_inputmethod:
+        spec = Spec{mir_create_input_method_window_spec(connection, width, height)};
         break;
     default:
-        spec = Spec{mir_connection_create_spec_for_normal_surface(connection, width, height, pixelFormat)};
+        spec = Spec{mir_create_normal_window_spec(connection, width, height)};
         break;
     }
 
+    mir_window_spec_set_pixel_format(spec.get(), pixelFormat);
+
     qCDebug(mirclient, "makeSurfaceSpec(window=%p): %s spec (type=0x%x, position=(%d, %d)px, size=(%dx%d)px)",
-            window, mirSurfaceTypeToStr(type), window->type(), location.left, location.top, width, height);
+            window, mirWindowTypeToStr(type), window->type(), location.left, location.top, width, height);
 
     return std::move(spec);
 }
 
-void setSizingConstraints(MirSurfaceSpec *spec, const QSize& minSize, const QSize& maxSize, const QSize& increment)
+void setSizingConstraints(MirWindowSpec *spec, const QSize& minSize, const QSize& maxSize, const QSize& increment)
 {
-    mir_surface_spec_set_min_width(spec, minSize.width());
-    mir_surface_spec_set_min_height(spec, minSize.height());
+    mir_window_spec_set_min_width(spec, minSize.width());
+    mir_window_spec_set_min_height(spec, minSize.height());
     if (maxSize.width() >= minSize.width()) {
-        mir_surface_spec_set_max_width(spec, maxSize.width());
+        mir_window_spec_set_max_width(spec, maxSize.width());
     }
     if (maxSize.height() >= minSize.height()) {
-        mir_surface_spec_set_max_height(spec, maxSize.height());
+        mir_window_spec_set_max_height(spec, maxSize.height());
     }
     if (increment.width() > 0) {
-        mir_surface_spec_set_width_increment(spec, increment.width());
+        mir_window_spec_set_width_increment(spec, increment.width());
     }
     if (increment.height() > 0) {
-        mir_surface_spec_set_height_increment(spec, increment.height());
+        mir_window_spec_set_height_increment(spec, increment.height());
     }
 }
 
-MirSurface *createMirSurface(QWindow *window, int mirOutputId, QMirClientWindow *parentWindowHandle,
+MirWindow *createMirWindow(QWindow *window, int mirOutputId, QMirClientWindow *parentWindowHandle,
                              MirPixelFormat pixelFormat, MirConnection *connection,
-                             mir_surface_event_callback inputCallback, void *inputContext)
+                             MirWindowEventCallback inputCallback, void *inputContext)
 {
     auto spec = makeSurfaceSpec(window, pixelFormat, parentWindowHandle, connection);
 
     // Install event handler as early as possible
-    mir_surface_spec_set_event_handler(spec.get(), inputCallback, inputContext);
+    mir_window_spec_set_event_handler(spec.get(), inputCallback, inputContext);
 
     const auto title = window->title().toUtf8();
-    mir_surface_spec_set_name(spec.get(), title.constData());
+    mir_window_spec_set_name(spec.get(), title.constData());
 
     setSizingConstraints(spec.get(), window->minimumSize(), window->maximumSize(), window->sizeIncrement());
 
     if (window->windowState() == Qt::WindowFullScreen) {
-        mir_surface_spec_set_fullscreen_on_output(spec.get(), mirOutputId);
+        mir_window_spec_set_fullscreen_on_output(spec.get(), mirOutputId);
     }
 
     if (window->flags() & LowChromeWindowHint) {
-        mir_surface_spec_set_shell_chrome(spec.get(), mir_shell_chrome_low);
+        mir_window_spec_set_shell_chrome(spec.get(), mir_shell_chrome_low);
     }
 
     if (!window->isVisible()) {
-        mir_surface_spec_set_state(spec.get(), mir_surface_state_hidden);
+        mir_window_spec_set_state(spec.get(), mir_window_state_hidden);
     }
 
-    auto surface = mir_surface_create_sync(spec.get());
-    Q_ASSERT(mir_surface_is_valid(surface));
+    auto surface = mir_create_window_sync(spec.get());
+    Q_ASSERT(mir_window_is_valid(surface));
     return surface;
 }
 
@@ -415,17 +417,17 @@
     void handleSurfaceResized(int width, int height);
     int needsRepaint() const;
 
-    MirSurfaceState state() const { return mir_surface_get_state(mMirSurface); }
-    void setState(MirSurfaceState state);
+    MirWindowState state() const { return mir_window_get_state(mMirWindow); }
+    void setState(MirWindowState state);
 
-    MirSurfaceType type() const { return mir_surface_get_type(mMirSurface); }
+    MirWindowType type() const { return mir_window_get_type(mMirWindow); }
 
     void setShellChrome(MirShellChrome shellChrome);
 
     EGLSurface eglSurface() const { return mEglSurface; }
-    MirSurface *mirSurface() const { return mMirSurface; }
+    MirWindow *mirWindow() const { return mMirWindow; }
 
-    void setSurfaceParent(MirSurface*);
+    void setSurfaceParent(MirWindow*);
     bool hasParent() const { return mParented; }
 
     QSurfaceFormat format() const { return mFormat; }
@@ -435,7 +437,7 @@
     QString persistentSurfaceId();
 
 private:
-    static void surfaceEventCallback(MirSurface* surface, const MirEvent *event, void* context);
+    static void surfaceEventCallback(MirWindow* surface, const MirEvent *event, void* context);
     void postEvent(const MirEvent *event);
 
     QWindow * const mWindow;
@@ -444,7 +446,7 @@
     MirConnection * const mConnection;
     QMirClientWindow * mParentWindowHandle{nullptr};
 
-    MirSurface* mMirSurface;
+    MirWindow* mMirWindow;
     const EGLDisplay mEglDisplay;
     EGLSurface mEglSurface;
 
@@ -507,15 +509,15 @@
 
     mParentWindowHandle = getParentIfNecessary(mWindow, input);
 
-    mMirSurface = createMirSurface(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
-    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirSurface), nullptr);
+    mMirWindow = createMirWindow(mWindow, outputId, mParentWindowHandle, mPixelFormat, connection, surfaceEventCallback, this);
+    mEglSurface = eglCreateWindowSurface(mEglDisplay, config, nativeWindowFor(mMirWindow), nullptr);
 
-    mNeedsExposeCatchup = mir_surface_get_visibility(mMirSurface) == mir_surface_visibility_occluded;
+    mNeedsExposeCatchup = mir_window_get_visibility(mMirWindow) == mir_window_visibility_occluded;
 
     // Window manager can give us a final size different from what we asked for
     // so let's check what we ended up getting
-    MirSurfaceParameters parameters;
-    mir_surface_get_parameters(mMirSurface, &parameters);
+    MirWindowParameters parameters;
+    mir_window_get_parameters(mMirWindow, &parameters);
 
     auto geom = mWindow->geometry();
     geom.setWidth(parameters.width);
@@ -538,18 +540,18 @@
 {
     if (mEglSurface != EGL_NO_SURFACE)
         eglDestroySurface(mEglDisplay, mEglSurface);
-    if (mMirSurface) {
-        mir_surface_release_sync(mMirSurface);
+    if (mMirWindow) {
+        mir_window_release_sync(mMirWindow);
     }
 }
 
 void UbuntuSurface::updateGeometry(const QRect &newGeometry)
 {
 
-    auto spec = Spec{mir_connection_create_spec_for_changes(mConnection)};
+    auto spec = Spec{mir_create_window_spec(mConnection)};
 
-    mir_surface_spec_set_width(spec.get(), newGeometry.width());
-    mir_surface_spec_set_height(spec.get(), newGeometry.height());
+    mir_window_spec_set_width(spec.get(), newGeometry.width());
+    mir_window_spec_set_height(spec.get(), newGeometry.height());
 
     MirRectangle mirRect {0,0,0,0};
 
@@ -568,26 +570,26 @@
         mirRect.top = newGeometry.y();
     }
 
-    mir_surface_spec_set_placement(spec.get(), &mirRect,
+    mir_window_spec_set_placement(spec.get(), &mirRect,
             mir_placement_gravity_northwest /* rect_gravity */, mir_placement_gravity_northwest /* surface_gravity */,
             (MirPlacementHints)0, 0 /* offset_dx */, 0 /* offset_dy */);
 
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::updateTitle(const QString& newTitle)
 {
     const auto title = newTitle.toUtf8();
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    mir_surface_spec_set_name(spec.get(), title.constData());
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    Spec spec{mir_create_window_spec(mConnection)};
+    mir_window_spec_set_name(spec.get(), title.constData());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::setSizingConstraints(const QSize& minSize, const QSize& maxSize, const QSize& increment)
 {
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
+    Spec spec{mir_create_window_spec(mConnection)};
     ::setSizingConstraints(spec.get(), minSize, maxSize, increment);
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 void UbuntuSurface::handleSurfaceResized(int width, int height)
@@ -620,17 +622,17 @@
     return 0;
 }
 
-void UbuntuSurface::setState(MirSurfaceState state)
+void UbuntuSurface::setState(MirWindowState state)
 {
-    mir_wait_for(mir_surface_set_state(mMirSurface, state));
+    mir_window_set_state(mMirWindow, state);
 }
 
 void UbuntuSurface::setShellChrome(MirShellChrome chrome)
 {
     if (chrome != mShellChrome) {
-        auto spec = Spec{mir_connection_create_spec_for_changes(mConnection)};
-        mir_surface_spec_set_shell_chrome(spec.get(), chrome);
-        mir_surface_apply_spec(mMirSurface, spec.get());
+        auto spec = Spec{mir_create_window_spec(mConnection)};
+        mir_window_spec_set_shell_chrome(spec.get(), chrome);
+        mir_window_apply_spec(mMirWindow, spec.get());
 
         mShellChrome = chrome;
     }
@@ -667,7 +669,7 @@
     }
 }
 
-void UbuntuSurface::surfaceEventCallback(MirSurface *surface, const MirEvent *event, void* context)
+void UbuntuSurface::surfaceEventCallback(MirWindow *surface, const MirEvent *event, void* context)
 {
     Q_UNUSED(surface);
     Q_ASSERT(context != nullptr);
@@ -697,20 +699,20 @@
     mInput->postEvent(mPlatformWindow, event);
 }
 
-void UbuntuSurface::setSurfaceParent(MirSurface* parent)
+void UbuntuSurface::setSurfaceParent(MirWindow* parent)
 {
     qCDebug(mirclient, "setSurfaceParent(window=%p)", mWindow);
 
     mParented = true;
-    Spec spec{mir_connection_create_spec_for_changes(mConnection)};
-    mir_surface_spec_set_parent(spec.get(), parent);
-    mir_surface_apply_spec(mMirSurface, spec.get());
+    Spec spec{mir_create_window_spec(mConnection)};
+    mir_window_spec_set_parent(spec.get(), parent);
+    mir_window_apply_spec(mMirWindow, spec.get());
 }
 
 QString UbuntuSurface::persistentSurfaceId()
 {
     if (mPersistentIdStr.isEmpty()) {
-        MirPersistentId* mirPermaId = mir_surface_request_persistent_id_sync(mMirSurface);
+        MirPersistentId* mirPermaId = mir_window_request_persistent_id_sync(mMirWindow);
         mPersistentIdStr = mir_persistent_id_as_string(mirPermaId);
         mir_persistent_id_release(mirPermaId);
     }
@@ -738,7 +740,7 @@
     qCDebug(mirclient, "QMirClientWindow(window=%p, screen=%p, input=%p, surf=%p) with title '%s', role: '%d'",
             w, w->screen()->handle(), input, mSurface.get(), qPrintable(window()->title()), roleFor(window()));
 
-    updatePanelHeightHack(mSurface->state() != mir_surface_state_fullscreen);
+    updatePanelHeightHack(mSurface->state() != mir_window_state_fullscreen);
 
     // queue the windowPropertyChanged signal. If it's emitted directly, the platformWindow will not yet be set for the window.
     QMetaObject::invokeMethod(mNativeInterface, "windowPropertyChanged", Qt::QueuedConnection,
@@ -878,7 +880,7 @@
 {
     if (mDebugExtention) {
         auto geom = QPlatformWindow::geometry();
-        geom.moveTopLeft(mDebugExtention->mapSurfacePointToScreen(mSurface->mirSurface(), QPoint(0,0)));
+        geom.moveTopLeft(mDebugExtention->mapWindowPointToScreen(mSurface->mirWindow(), QPoint(0,0)));
         return geom;
     } else {
         return QPlatformWindow::geometry();
@@ -919,7 +921,7 @@
             // so morph it into a modal dialog
             auto parent = transientParentFor(window());
             if (parent) {
-                mSurface->setSurfaceParent(parent->mirSurface());
+                mSurface->setSurfaceParent(parent->mirWindow());
             }
         }
     }
@@ -961,7 +963,7 @@
 QPoint QMirClientWindow::mapToGlobal(const QPoint &pos) const
 {
     if (mDebugExtention) {
-        return mDebugExtention->mapSurfacePointToScreen(mSurface->mirSurface(), pos);
+        return mDebugExtention->mapWindowPointToScreen(mSurface->mirWindow(), pos);
     } else {
         return pos;
     }
@@ -972,9 +974,9 @@
     return mSurface->eglSurface();
 }
 
-MirSurface *QMirClientWindow::mirSurface() const
+MirWindow *QMirClientWindow::mirWindow() const
 {
-    return mSurface->mirSurface();
+    return mSurface->mirWindow();
 }
 
 WId QMirClientWindow::winId() const
@@ -1008,7 +1010,7 @@
     if (!qFuzzyCompare(scale, mScale)) {
         mScale = scale;
         // update the panelHeight hack since it depends on GU
-        updatePanelHeightHack(mSurface->state() != mir_surface_state_fullscreen);
+        updatePanelHeightHack(mSurface->state() != mir_window_state_fullscreen);
 
         Q_EMIT mNativeInterface->windowPropertyChanged(this, QStringLiteral("scale"));
     }
@@ -1017,14 +1019,14 @@
 void QMirClientWindow::updateSurfaceState()
 {
     QMutexLocker lock(&mMutex);
-    MirSurfaceState newState = mWindowVisible ? qtWindowStateToMirSurfaceState(mWindowState) :
-                                                mir_surface_state_hidden;
-    qCDebug(mirclient, "updateSurfaceState (window=%p, surfaceState=%s)", window(), mirSurfaceStateToStr(newState));
+    MirWindowState newState = mWindowVisible ? qtWindowStateToMirWindowState(mWindowState) :
+                                                mir_window_state_hidden;
+    qCDebug(mirclient, "updateSurfaceState (window=%p, surfaceState=%s)", window(), mirWindowStateToStr(newState));
     if (newState != mSurface->state()) {
         mSurface->setState(newState);
 
         lock.unlock();
-        updatePanelHeightHack(newState != mir_surface_state_fullscreen);
+        updatePanelHeightHack(newState != mir_window_state_fullscreen);
     }
 }
 

=== modified file 'src/ubuntumirclient/qmirclientwindow.h'
--- src/ubuntumirclient/qmirclientwindow.h	2017-02-08 16:39:07 +0000
+++ src/ubuntumirclient/qmirclientwindow.h	2017-02-08 16:39:07 +0000
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2014-2016 Canonical, Ltd.
+** Copyright (C) 2014-2017 Canonical, Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -46,6 +46,7 @@
 #include <QMutex>
 
 #include <mir_toolkit/common.h> // needed only for MirFormFactor enum
+#include <mir_toolkit/mir_window.h>
 
 #include <memory>
 
@@ -57,7 +58,6 @@
 class QMirClientInput;
 class QMirClientScreen;
 class UbuntuSurface;
-struct MirSurface;
 class MirConnection;
 
 class QMirClientWindow : public QObject, public QPlatformWindow
@@ -89,7 +89,7 @@
 
     // New methods.
     void *eglSurface() const;
-    MirSurface *mirSurface() const;
+    MirWindow *mirWindow() const;
     void handleSurfaceResized(int width, int height);
     void handleSurfaceExposeChange(bool exposed);
     void handleSurfaceFocusChanged(bool focused);