Merge remote-tracking branch 'origin/5.12' into dev

Change-Id: I40724946222f7e51b3cf36a2ce1cd60d7801f41a

31 files changed, 2078 insertions, 71 deletions

diff --git a/src/3rdparty/protocol/qt_attribution.json b/src/3rdparty/protocol/qt_attribution.json
index 84dafe938..ba199812b 100644
--- a/src/3rdparty/protocol/qt_attribution.json
+++ b/src/3rdparty/protocol/qt_attribution.json
@@ -74,7 +74,7 @@ Copyright (c) 2013 BMW Car IT GmbH"
         "Name": "Wayland XDG Shell Protocol",
         "QDocModule": "qtwaylandcompositor",
         "QtUsage": "Used in the Qt Wayland Compositor, and the Qt Wayland platform plugin.",
-        "Files": "xdg-shell-unstable-v5.xml xdg-shell-unstable-v6.xml xdg-shell.xml ../../compositor/extensions/pregenerated/3rdparty/qwayland-server-xdg-shell-unstable-v5.cpp ../../compositor/extensions/pregenerated/3rdparty/qwayland-server-xdg-shell-unstable-v5_p.h ../../compositor/extensions/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c ../../compositor/extensions/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-server-protocol_p.h",
+        "Files": " xdg-shell-unstable-v5.xml xdg-shell-unstable-v6.xml xdg-shell.xml ../../compositor/extensions/pregenerated/3rdparty/qwayland-server-xdg-shell-unstable-v5.cpp ../../compositor/extensions/pregenerated/3rdparty/qwayland-server-xdg-shell-unstable-v5_p.h ../../compositor/extensions/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c ../../compositor/extensions/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-server-protocol_p.h ../../plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5.cpp ../../plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5_p.h ../../plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-client-protocol_p.h ../../plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c",
 
         "Description": "The XDG-Shell protocol is an extended way to manage surfaces under Wayland compositors.",
         "Homepage": "https://wayland.freedesktop.org",
diff --git a/src/client/configure.json b/src/client/configure.json
index b11416f68..ef5e87bb7 100644
--- a/src/client/configure.json
+++ b/src/client/configure.json
@@ -101,15 +101,20 @@
             "condition": "features.wayland-client && features.opengl && !features.opengles2 && features.xlib && libs.xcomposite && libs.glx",
             "output": [ "privateFeature" ]
         },
-        "drm-egl-server": {
+        "wayland-drm-egl-server-buffer": {
             "label": "DRM EGL",
             "condition": "features.wayland-client && features.opengl && features.egl && tests.drm-egl-server",
             "output": [ "privateFeature" ]
         },
-        "libhybris-egl-server": {
+        "wayland-libhybris-egl-server-buffer": {
             "label": "libhybris EGL",
             "condition": "features.wayland-client && features.opengl && features.egl && tests.libhybris-egl-server",
             "output": [ "privateFeature" ]
+        },
+        "wayland-shm-emulation-server-buffer": {
+            "label": "Shm emulation server buffer integration",
+            "condition": "features.wayland-client && features.opengl",
+            "output": [ "privateFeature" ]
         }
     },
 
@@ -130,8 +135,9 @@
                 "wayland-brcm",
                 "xcomposite-egl",
                 "xcomposite-glx",
-                "drm-egl-server",
-                "libhybris-egl-server"
+                "wayland-drm-egl-server-buffer",
+                "wayland-libhybris-egl-server-buffer",
+                "wayland-shm-emulation-server-buffer"
             ]
         },
         "wayland-client"
diff --git a/src/compositor/compositor_api/qwaylandoutput.cpp b/src/compositor/compositor_api/qwaylandoutput.cpp
index c9cc5a136..17c56cfdc 100644
--- a/src/compositor/compositor_api/qwaylandoutput.cpp
+++ b/src/compositor/compositor_api/qwaylandoutput.cpp
@@ -944,7 +944,10 @@ void QWaylandOutput::surfaceLeave(QWaylandSurface *surface)
 {
     if (!surface || !surface->client())
         return;
-    QWaylandSurfacePrivate::get(surface)->send_leave(resourceForClient(surface->client()));
+
+    auto *clientResource = resourceForClient(surface->client());
+    if (clientResource)
+        QWaylandSurfacePrivate::get(surface)->send_leave(clientResource);
 }
 
 /*!
diff --git a/src/compositor/compositor_api/qwaylandquickchildren.h b/src/compositor/compositor_api/qwaylandquickchildren.h
index e1f51f4fe..7d821ab50 100644
--- a/src/compositor/compositor_api/qwaylandquickchildren.h
+++ b/src/compositor/compositor_api/qwaylandquickchildren.h
@@ -56,6 +56,8 @@
 #include <QtCore/QVector>
 #endif
 
+#include <QtCore/qglobal.h>
+
 QT_BEGIN_NAMESPACE
 
 #ifdef QT_WAYLAND_COMPOSITOR_QUICK
diff --git a/src/compositor/compositor_api/qwaylandquickitem.cpp b/src/compositor/compositor_api/qwaylandquickitem.cpp
index 7f0685fcf..fd9b1b800 100644
--- a/src/compositor/compositor_api/qwaylandquickitem.cpp
+++ b/src/compositor/compositor_api/qwaylandquickitem.cpp
@@ -288,7 +288,7 @@ public:
                     m_sgTex->bind();
                 }
             } else {
-                QQuickWindow::CreateTextureOptions opt = QQuickWindow::TextureOwnsGLTexture;
+                QQuickWindow::CreateTextureOptions opt;
                 QWaylandQuickSurface *surface = qobject_cast<QWaylandQuickSurface *>(surfaceItem->surface());
                 if (surface && surface->useTextureAlpha()) {
                     opt |= QQuickWindow::TextureHasAlphaChannel;
diff --git a/src/compositor/configure.json b/src/compositor/configure.json
index 21f486d78..6864a94f9 100644
--- a/src/compositor/configure.json
+++ b/src/compositor/configure.json
@@ -106,16 +106,21 @@
             "condition": "features.wayland-server && features.opengl && !features.opengles2 && libs.xcomposite && libs.glx",
             "output": [ "privateFeature" ]
         },
-        "drm-egl-server": {
+        "wayland-drm-egl-server-buffer": {
             "label": "DRM EGL",
             "condition": "features.wayland-server && features.opengl && features.egl && tests.drm-egl-server",
             "output": [ "privateFeature" ]
         },
-        "libhybris-egl-server": {
+        "wayland-libhybris-egl-server-buffer": {
             "label": "libhybris EGL",
             "condition": "features.wayland-server && features.opengl && features.egl && tests.libhybris-egl-server",
             "output": [ "privateFeature" ]
         },
+        "wayland-shm-emulation-server-buffer": {
+            "label": "Shm emulation server buffer",
+            "condition": "features.wayland-server && features.opengl",
+            "output": [ "privateFeature" ]
+        },
         "wayland-layer-integration-vsp2": {
             "label": "VSP2 hardware layer integration",
             "condition": "features.wayland-server && features.eglfs_vsp2 && libs.wayland-kms",
diff --git a/src/compositor/extensions/qwaylandxdgdecorationv1.cpp b/src/compositor/extensions/qwaylandxdgdecorationv1.cpp
index a44d5c19d..1abd5e3fc 100644
--- a/src/compositor/extensions/qwaylandxdgdecorationv1.cpp
+++ b/src/compositor/extensions/qwaylandxdgdecorationv1.cpp
@@ -44,11 +44,66 @@
 
 QT_BEGIN_NAMESPACE
 
+/*!
+    \qmltype XdgDecorationManagerV1
+    \inqmlmodule QtWayland.Compositor
+    \since 5.12
+    \brief Provides an extension for negotiation of server-side and client-side window decorations
+
+    The XdgDecorationManagerV1 extension provides a way for a compositor to announce support for
+    server-side window decorations, and for xdg-shell clients to communicate whether they prefer
+    client-side or server-side decorations.
+
+    XdgDecorationManagerV1 corresponds to the Wayland interface, \c zxdg_decoration_manager_v1.
+
+    To provide the functionality of the extension in a compositor, create an instance of the
+    XdgDecorationManagerV1 component and add it to the list of extensions supported by the compositor:
+
+    \code
+    import QtWayland.Compositor 1.3
+
+    WaylandCompositor {
+        // Xdg decoration manager assumes xdg-shell is being used
+        XdgShell {
+            onToplevelCreated: // ...
+        }
+        XdgDecorationManagerV1 {
+            // Provide a hint to clients that support the extension they should use server-side
+            // decorations.
+            preferredMode: XdgToplevel.ServerSideDecoration
+        }
+    }
+    \endcode
+
+    \sa XdgToplevel::decorationMode
+*/
+
+/*!
+    \class QWaylandXdgDecorationManagerV1
+    \inmodule QtWaylandCompositor
+    \since 5.12
+    \brief Provides an extension for negotiation of server-side and client-side window decorations
+
+    The QWaylandXdgDecorationManagerV1 extension provides a way for a compositor to announce support
+    for server-side window decorations, and for xdg-shell clients to communicate whether they prefer
+    client-side or server-side decorations.
+
+    QWaylandXdgDecorationManagerV1 corresponds to the Wayland interface, \c zxdg_decoration_manager_v1.
+
+    \sa QWaylandXdgToplevel::decorationMode
+*/
+
+/*!
+    Constructs a QWaylandXdgDecorationManagerV1 object.
+*/
 QWaylandXdgDecorationManagerV1::QWaylandXdgDecorationManagerV1()
     : QWaylandCompositorExtensionTemplate<QWaylandXdgDecorationManagerV1>(*new QWaylandXdgDecorationManagerV1Private)
 {
 }
 
+/*!
+    Initializes the extension.
+*/
 void QWaylandXdgDecorationManagerV1::initialize()
 {
     Q_D(QWaylandXdgDecorationManagerV1);
@@ -62,22 +117,41 @@ void QWaylandXdgDecorationManagerV1::initialize()
     d->init(compositor->display(), 1);
 }
 
+/*!
+    \qmlproperty string QtWaylandCompositor::XdgDecorationManagerV1::preferredMode
+
+    This property holds the decoration mode the compositor prefers.
+
+    This is the mode used for clients that don't indicate a preference for server-side or
+    client-side decorations.
+*/
+/*!
+    \property QWaylandXdgDecorationManagerV1::preferredMode
+
+    This property holds the decoration mode the compositor prefers.
+
+    This is the mode used for clients that don't indicate a preference for server-side or
+    client-side decorations.
+*/
 QWaylandXdgToplevel::DecorationMode QWaylandXdgDecorationManagerV1::preferredMode() const
 {
     Q_D(const QWaylandXdgDecorationManagerV1);
-    return d->m_defaultMode;
+    return d->m_preferredMode;
 }
 
-void QWaylandXdgDecorationManagerV1::setPreferredMode(QWaylandXdgToplevel::DecorationMode defaultMode)
+void QWaylandXdgDecorationManagerV1::setPreferredMode(QWaylandXdgToplevel::DecorationMode preferredMode)
 {
     Q_D(QWaylandXdgDecorationManagerV1);
-    if (d->m_defaultMode == defaultMode)
+    if (d->m_preferredMode == preferredMode)
         return;
 
-    d->m_defaultMode = defaultMode;
-    emit defaultModeChanged();
+    d->m_preferredMode = preferredMode;
+    emit preferredModeChanged();
 }
 
+/*!
+    Returns the Wayland interface for the QWaylandXdgDecorationManagerV1.
+*/
 const wl_interface *QWaylandXdgDecorationManagerV1::interface()
 {
     return QWaylandXdgDecorationManagerV1Private::interface();
@@ -118,10 +192,15 @@ QWaylandXdgToplevelDecorationV1::QWaylandXdgToplevelDecorationV1(QWaylandXdgTopl
     Q_ASSERT(toplevel);
     auto *toplevelPrivate = QWaylandXdgToplevelPrivate::get(toplevel);
     Q_ASSERT(!toplevelPrivate->m_decoration);
-    toplevelPrivate->m_decoration.reset(this);
+    toplevelPrivate->m_decoration = this;
     sendConfigure(manager->preferredMode());
 }
 
+QWaylandXdgToplevelDecorationV1::~QWaylandXdgToplevelDecorationV1()
+{
+    QWaylandXdgToplevelPrivate::get(m_toplevel)->m_decoration = nullptr;
+}
+
 void QWaylandXdgToplevelDecorationV1::sendConfigure(QWaylandXdgToplevelDecorationV1::DecorationMode mode)
 {
     if (configuredMode() == mode)
@@ -146,8 +225,7 @@ void QWaylandXdgToplevelDecorationV1::sendConfigure(QWaylandXdgToplevelDecoratio
 void QWaylandXdgToplevelDecorationV1::zxdg_toplevel_decoration_v1_destroy_resource(Resource *resource)
 {
     Q_UNUSED(resource);
-    auto *toplevelPrivate = QWaylandXdgToplevelPrivate::get(m_toplevel);
-    toplevelPrivate->m_decoration.reset();
+    delete this;
 }
 
 void QWaylandXdgToplevelDecorationV1::zxdg_toplevel_decoration_v1_destroy(Resource *resource)
@@ -157,23 +235,25 @@ void QWaylandXdgToplevelDecorationV1::zxdg_toplevel_decoration_v1_destroy(Resour
 
 void QWaylandXdgToplevelDecorationV1::zxdg_toplevel_decoration_v1_set_mode(Resource *resource, uint32_t mode)
 {
-    m_clientPreferredMode = DecorationMode(mode);
+    Q_UNUSED(resource);
+    m_clientPreferredMode = mode;
     handleClientPreferredModeChanged();
 }
 
 void QWaylandXdgToplevelDecorationV1::zxdg_toplevel_decoration_v1_unset_mode(Resource *resource)
 {
-    m_clientPreferredMode = DecorationMode::DefaultDecorationMode;
+    Q_UNUSED(resource);
+    m_clientPreferredMode = 0;
     handleClientPreferredModeChanged();
 }
 
 void QWaylandXdgToplevelDecorationV1::handleClientPreferredModeChanged()
 {
     if (m_clientPreferredMode != m_configuredMode) {
-        if (m_clientPreferredMode == DecorationMode::DefaultDecorationMode)
+        if (m_clientPreferredMode == 0)
             sendConfigure(m_manager->preferredMode());
         else
-            sendConfigure(m_clientPreferredMode);
+            sendConfigure(DecorationMode(m_clientPreferredMode));
     }
 }
 
diff --git a/src/compositor/extensions/qwaylandxdgdecorationv1.h b/src/compositor/extensions/qwaylandxdgdecorationv1.h
index 649f3d162..4390716e8 100644
--- a/src/compositor/extensions/qwaylandxdgdecorationv1.h
+++ b/src/compositor/extensions/qwaylandxdgdecorationv1.h
@@ -48,7 +48,7 @@ class Q_WAYLAND_COMPOSITOR_EXPORT QWaylandXdgDecorationManagerV1 : public QWayla
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QWaylandXdgDecorationManagerV1)
-    Q_PROPERTY(QWaylandXdgToplevel::DecorationMode preferredMode READ preferredMode WRITE setPreferredMode NOTIFY defaultModeChanged)
+    Q_PROPERTY(QWaylandXdgToplevel::DecorationMode preferredMode READ preferredMode WRITE setPreferredMode NOTIFY preferredModeChanged)
 
 public:
     explicit QWaylandXdgDecorationManagerV1();
@@ -61,7 +61,7 @@ public:
     static const struct wl_interface *interface();
 
 Q_SIGNALS:
-    void defaultModeChanged();
+    void preferredModeChanged();
 };
 
 QT_END_NAMESPACE
diff --git a/src/compositor/extensions/qwaylandxdgdecorationv1_p.h b/src/compositor/extensions/qwaylandxdgdecorationv1_p.h
index c09cbc12e..fdd555abb 100644
--- a/src/compositor/extensions/qwaylandxdgdecorationv1_p.h
+++ b/src/compositor/extensions/qwaylandxdgdecorationv1_p.h
@@ -72,7 +72,7 @@ protected:
     void zxdg_decoration_manager_v1_get_toplevel_decoration(Resource *resource, uint id, ::wl_resource *toplevelResource) override;
 
 private:
-    DecorationMode m_defaultMode = DecorationMode::ClientSideDecoration;
+    DecorationMode m_preferredMode = DecorationMode::ClientSideDecoration;
 };
 
 class Q_WAYLAND_COMPOSITOR_EXPORT QWaylandXdgToplevelDecorationV1
@@ -83,8 +83,9 @@ public:
     explicit QWaylandXdgToplevelDecorationV1(QWaylandXdgToplevel *toplevel,
                                              QWaylandXdgDecorationManagerV1 *manager,
                                              wl_client *client, int id);
+    ~QWaylandXdgToplevelDecorationV1() override;
 
-    DecorationMode configuredMode() const { return m_configuredMode; }
+    DecorationMode configuredMode() const { return DecorationMode(m_configuredMode); }
     void sendConfigure(DecorationMode mode);
 
 protected:
@@ -98,8 +99,8 @@ private:
 
     QWaylandXdgToplevel *m_toplevel = nullptr;
     QWaylandXdgDecorationManagerV1 *m_manager = nullptr;
-    DecorationMode m_configuredMode = DecorationMode::DefaultDecorationMode;
-    DecorationMode m_clientPreferredMode = DecorationMode::DefaultDecorationMode;
+    uint m_configuredMode = 0;
+    uint m_clientPreferredMode = 0;
 };
 
 QT_END_NAMESPACE
diff --git a/src/compositor/extensions/qwaylandxdgshell.cpp b/src/compositor/extensions/qwaylandxdgshell.cpp
index 90841b117..4a0db2a53 100644
--- a/src/compositor/extensions/qwaylandxdgshell.cpp
+++ b/src/compositor/extensions/qwaylandxdgshell.cpp
@@ -731,6 +731,33 @@ QWaylandXdgToplevel::QWaylandXdgToplevel(QWaylandXdgSurface *xdgSurface, QWaylan
     sendConfigure({0, 0}, states);
 }
 
+QWaylandXdgToplevel::~QWaylandXdgToplevel()
+{
+    Q_D(QWaylandXdgToplevel);
+    // Usually, the decoration is destroyed by the client (according to the protocol),
+    // but if the client misbehaves, or is shut down, we need to clean up here.
+    if (Q_UNLIKELY(d->m_decoration))
+        wl_resource_destroy(d->m_decoration->resource()->handle);
+    Q_ASSERT(!d->m_decoration);
+}
+
+/*!
+ * \qmlproperty XdgSurface QtWaylandCompositor::XdgToplevel::xdgSurface
+ *
+ * This property holds the XdgSurface for this XdgToplevel.
+ */
+
+/*!
+ * \property QWaylandXdgToplevel::xdgSurface
+ *
+ * This property holds the QWaylandXdgSurface for this QWaylandXdgToplevel.
+ */
+QWaylandXdgSurface *QWaylandXdgToplevel::xdgSurface() const
+{
+    Q_D(const QWaylandXdgToplevel);
+    return d->m_xdgSurface;
+}
+
 /*!
  * \qmlproperty XdgToplevel QtWaylandCompositor::XdgToplevel::parentToplevel
  *
@@ -904,6 +931,34 @@ bool QWaylandXdgToplevel::activated() const
     return d->m_lastAckedConfigure.states.contains(QWaylandXdgToplevel::State::ActivatedState);
 }
 
+/*!
+ * \enum QWaylandXdgToplevel::DecorationMode
+ *
+ * This enum type is used to specify the window decoration mode for toplevel windows.
+ *
+ * \value ServerSideDecoration The compositor should draw window decorations.
+ * \value ClientSideDecoration The client should draw window decorations.
+ */
+
+/*!
+ * \qmlproperty enumeration QtWaylandCompositor::XdgToplevel::decorationMode
+ *
+ * This property holds the current window decoration mode for this toplevel.
+ *
+ * The possible values are:
+ * \value XdgToplevel.ServerSideDecoration The compositor should draw window decorations.
+ * \value XdgToplevel.ClientSideDecoration The client should draw window decorations.
+ *
+ * \sa XdgDecorationManagerV1
+ */
+
+/*!
+ * \property QWaylandXdgToplevel::decorationMode
+ *
+ * This property holds the current window decoration mode for this toplevel.
+ *
+ * \sa QWaylandXdgDecorationManagerV1
+ */
 QWaylandXdgToplevel::DecorationMode QWaylandXdgToplevel::decorationMode() const
 {
     Q_D(const QWaylandXdgToplevel);
@@ -1303,6 +1358,9 @@ void QWaylandXdgToplevelPrivate::xdg_toplevel_destroy_resource(QtWaylandServer::
 
 void QWaylandXdgToplevelPrivate::xdg_toplevel_destroy(QtWaylandServer::xdg_toplevel::Resource *resource)
 {
+    if (Q_UNLIKELY(m_decoration))
+        qWarning() << "Client error: xdg_toplevel destroyed before its decoration object";
+
     wl_resource_destroy(resource->handle);
     //TODO: Should the xdg surface be desroyed as well? Or is it allowed to recreate a new toplevel for it?
 }
diff --git a/src/compositor/extensions/qwaylandxdgshell.h b/src/compositor/extensions/qwaylandxdgshell.h
index 2b6f63564..774dd2282 100644
--- a/src/compositor/extensions/qwaylandxdgshell.h
+++ b/src/compositor/extensions/qwaylandxdgshell.h
@@ -142,6 +142,7 @@ class Q_WAYLAND_COMPOSITOR_EXPORT QWaylandXdgToplevel : public QObject
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QWaylandXdgToplevel)
+    Q_PROPERTY(QWaylandXdgSurface *xdgSurface READ xdgSurface CONSTANT)
     Q_PROPERTY(QWaylandXdgToplevel *parentToplevel READ parentToplevel NOTIFY parentToplevelChanged)
     Q_PROPERTY(QString title READ title NOTIFY titleChanged)
     Q_PROPERTY(QString appId READ appId NOTIFY appIdChanged)
@@ -163,14 +164,15 @@ public:
     Q_ENUM(State)
 
     enum DecorationMode {
-        DefaultDecorationMode,
-        ClientSideDecoration,
-        ServerSideDecoration,
+        ClientSideDecoration = 1,
+        ServerSideDecoration = 2,
     };
     Q_ENUM(DecorationMode)
 
     explicit QWaylandXdgToplevel(QWaylandXdgSurface *xdgSurface, QWaylandResource &resource);
+    ~QWaylandXdgToplevel() override;
 
+    QWaylandXdgSurface *xdgSurface() const;
     QWaylandXdgToplevel *parentToplevel() const;
 
     QString title() const;
diff --git a/src/compositor/extensions/qwaylandxdgshell_p.h b/src/compositor/extensions/qwaylandxdgshell_p.h
index e87bb17f0..5ef8bde3d 100644
--- a/src/compositor/extensions/qwaylandxdgshell_p.h
+++ b/src/compositor/extensions/qwaylandxdgshell_p.h
@@ -178,7 +178,7 @@ public:
     QString m_appId;
     QSize m_maxSize;
     QSize m_minSize = {0, 0};
-    QScopedPointer<QWaylandXdgToplevelDecorationV1> m_decoration;
+    QWaylandXdgToplevelDecorationV1 *m_decoration = nullptr;
 
     static QWaylandSurfaceRole s_role;
 };
diff --git a/src/compositor/extensions/qwaylandxdgshellv6integration.cpp b/src/compositor/extensions/qwaylandxdgshellv6integration.cpp
index a37ee2a3c..61a9092a3 100644
--- a/src/compositor/extensions/qwaylandxdgshellv6integration.cpp
+++ b/src/compositor/extensions/qwaylandxdgshellv6integration.cpp
@@ -109,7 +109,7 @@ bool XdgToplevelV6Integration::mouseReleaseEvent(QMouseEvent *event)
 {
     Q_UNUSED(event);
 
-    if (grabberState == GrabberState::Move) {
+    if (grabberState != GrabberState::Default) {
         grabberState = GrabberState::Default;
         return true;
     }
diff --git a/src/hardwareintegration/client/wayland-egl/qwaylandeglwindow.cpp b/src/hardwareintegration/client/wayland-egl/qwaylandeglwindow.cpp
index 3009f9d63..f10a7469a 100644
--- a/src/hardwareintegration/client/wayland-egl/qwaylandeglwindow.cpp
+++ b/src/hardwareintegration/client/wayland-egl/qwaylandeglwindow.cpp
@@ -133,13 +133,16 @@ void QWaylandEglWindow::updateSurface(bool create)
 
                 m_resize = true;
             }
-        } else if (create) {
-            m_waylandEglWindow = wl_egl_window_create(object(), sizeWithMargins.width(), sizeWithMargins.height());
+        } else if (create && wl_surface::isInitialized()) {
+            ::wl_surface *wlSurface = wl_surface::object();
+            m_waylandEglWindow = wl_egl_window_create(wlSurface, sizeWithMargins.width(), sizeWithMargins.height());
         }
 
-        if (!m_eglSurface && create) {
+        if (!m_eglSurface && m_waylandEglWindow && create) {
             EGLNativeWindowType eglw = (EGLNativeWindowType) m_waylandEglWindow;
             m_eglSurface = eglCreateWindowSurface(m_clientBufferIntegration->eglDisplay(), m_eglConfig, eglw, 0);
+            if (Q_UNLIKELY(m_eglSurface == EGL_NO_SURFACE))
+                qCWarning(lcQpaWayland, "Could not create EGL surface (EGL error 0x%x)\n", eglGetError());
         }
     }
 }
diff --git a/src/hardwareintegration/client/wayland-egl/qwaylandglcontext.cpp b/src/hardwareintegration/client/wayland-egl/qwaylandglcontext.cpp
index 8b0fb638e..4f2aa8af5 100644
--- a/src/hardwareintegration/client/wayland-egl/qwaylandglcontext.cpp
+++ b/src/hardwareintegration/client/wayland-egl/qwaylandglcontext.cpp
@@ -412,7 +412,7 @@ bool QWaylandGLContext::makeCurrent(QPlatformSurface *surface)
         window->createDecoration();
 
     if (eglSurface == EGL_NO_SURFACE) {
-        window->updateSurface(window->isExposed());
+        window->updateSurface(true);
         eglSurface = window->eglSurface();
     }
 
diff --git a/src/plugins/hardwareintegration/client/client.pro b/src/plugins/hardwareintegration/client/client.pro
index f1c71f084..eab62f8d0 100644
--- a/src/plugins/hardwareintegration/client/client.pro
+++ b/src/plugins/hardwareintegration/client/client.pro
@@ -9,10 +9,10 @@ qtConfig(xcomposite-egl): \
     SUBDIRS += xcomposite-egl
 qtConfig(xcomposite-glx): \
     SUBDIRS += xcomposite-glx
-qtConfig(drm-egl-server): \
+
+qtConfig(wayland-drm-egl-server-buffer): \
     SUBDIRS += drm-egl-server
-qtConfig(libhybris-egl-server): \
+qtConfig(wayland-libhybris-egl-server-buffer): \
     SUBDIRS += libhybris-egl-server
-
-### TODO: make shm-emulation configurable
-SUBDIRS += shm-emulation-server
+qtConfig(wayland-shm-emulation-server-buffer): \
+    SUBDIRS += shm-emulation-server
diff --git a/src/plugins/hardwareintegration/compositor/compositor.pro b/src/plugins/hardwareintegration/compositor/compositor.pro
index 22301d07e..55bf1a7df 100644
--- a/src/plugins/hardwareintegration/compositor/compositor.pro
+++ b/src/plugins/hardwareintegration/compositor/compositor.pro
@@ -9,12 +9,12 @@ qtConfig(xcomposite-egl): \
     SUBDIRS += xcomposite-egl
 qtConfig(xcomposite-glx): \
     SUBDIRS += xcomposite-glx
-qtConfig(drm-egl-server): \
+
+qtConfig(wayland-drm-egl-server-buffer): \
     SUBDIRS += drm-egl-server
-qtConfig(libhybris-egl-server): \
+qtConfig(wayland-libhybris-egl-server-buffer): \
     SUBDIRS += libhybris-egl-server
-
-### TODO: make shm-emulation configurable
-SUBDIRS += shm-emulation-server
+qtConfig(wayland-shm-emulation-server-buffer): \
+    SUBDIRS += shm-emulation-server
 
 SUBDIRS += hardwarelayer
diff --git a/src/plugins/shellintegration/wl-shell/qwaylandwlshellintegration.cpp b/src/plugins/shellintegration/wl-shell/qwaylandwlshellintegration.cpp
index be156dad2..008da3d8a 100644
--- a/src/plugins/shellintegration/wl-shell/qwaylandwlshellintegration.cpp
+++ b/src/plugins/shellintegration/wl-shell/qwaylandwlshellintegration.cpp
@@ -49,6 +49,10 @@ namespace QtWaylandClient {
 
 bool QWaylandWlShellIntegration::initialize(QWaylandDisplay *display)
 {
+    qCWarning(lcQpaWayland) << "\"wl-shell\" is a deprecated shell extension, prefer using"
+                            << "\"xdg-shell-v6\" or \"xdg-shell\" if supported by the compositor"
+                            << "by setting the environment variable QT_WAYLAND_SHELL_INTEGRATION";
+
     Q_FOREACH (QWaylandDisplay::RegistryGlobal global, display->globals()) {
         if (global.interface == QLatin1String("wl_shell")) {
             m_wlShell = new QtWayland::wl_shell(display->wl_registry(), global.id, 1);
diff --git a/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5.cpp b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5.cpp
new file mode 100644
index 000000000..0115eb1da
--- /dev/null
+++ b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5.cpp
@@ -0,0 +1,398 @@
+// Hand-edited to resolve conflicts with xdg-shell stable
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include "qwayland-xdg-shell-unstable-v5_p.h"
+
+QT_BEGIN_NAMESPACE
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Wmissing-field-initializers")
+
+namespace QtWayland {
+    xdg_shell_v5::xdg_shell_v5(struct ::wl_registry *registry, int id, int version)
+    {
+        init(registry, id, version);
+    }
+
+    xdg_shell_v5::xdg_shell_v5(struct ::xdg_shell_v5 *obj)
+        : m_xdg_shell(obj)
+    {
+        init_listener();
+    }
+
+    xdg_shell_v5::xdg_shell_v5()
+        : m_xdg_shell(nullptr)
+    {
+    }
+
+    xdg_shell_v5::~xdg_shell_v5()
+    {
+    }
+
+    void xdg_shell_v5::init(struct ::wl_registry *registry, int id, int version)
+    {
+        m_xdg_shell = static_cast<struct ::xdg_shell_v5 *>(wl_registry_bind(registry, id, &xdg_shell_v5_interface, version));
+        init_listener();
+    }
+
+    void xdg_shell_v5::init(struct ::xdg_shell_v5 *obj)
+    {
+        m_xdg_shell = obj;
+        init_listener();
+    }
+
+    bool xdg_shell_v5::isInitialized() const
+    {
+        return m_xdg_shell != nullptr;
+    }
+
+    const struct wl_interface *xdg_shell_v5::interface()
+    {
+        return &::xdg_shell_v5_interface;
+    }
+
+    void xdg_shell_v5::destroy()
+    {
+        xdg_shell_destroy(
+            m_xdg_shell);
+        m_xdg_shell = nullptr;
+    }
+
+    void xdg_shell_v5::use_unstable_version(int32_t version)
+    {
+        xdg_shell_use_unstable_version(
+            m_xdg_shell,
+            version);
+    }
+
+    struct ::xdg_surface_v5 *xdg_shell_v5::get_xdg_surface(struct ::wl_surface *surface)
+    {
+        return xdg_shell_get_xdg_surface(
+            m_xdg_shell,
+            surface);
+    }
+
+    struct ::xdg_popup_v5 *xdg_shell_v5::get_xdg_popup(struct ::wl_surface *surface, struct ::wl_surface *parent, struct ::wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+    {
+        return xdg_shell_get_xdg_popup(
+            m_xdg_shell,
+            surface,
+            parent,
+            seat,
+            serial,
+            x,
+            y);
+    }
+
+    void xdg_shell_v5::pong(uint32_t serial)
+    {
+        xdg_shell_pong(
+            m_xdg_shell,
+            serial);
+    }
+
+    void xdg_shell_v5::xdg_shell_ping(uint32_t )
+    {
+    }
+
+    void xdg_shell_v5::handle_ping(
+        void *data,
+        struct ::xdg_shell_v5 *object,
+        uint32_t serial)
+    {
+        Q_UNUSED(object);
+        static_cast<xdg_shell_v5 *>(data)->xdg_shell_ping(
+            serial);
+    }
+
+    const struct xdg_shell_listener xdg_shell_v5::m_xdg_shell_listener = {
+        xdg_shell_v5::handle_ping
+    };
+
+    void xdg_shell_v5::init_listener()
+    {
+        xdg_shell_add_listener(m_xdg_shell, &m_xdg_shell_listener, this);
+    }
+
+    xdg_surface_v5::xdg_surface_v5(struct ::wl_registry *registry, int id, int version)
+    {
+        init(registry, id, version);
+    }
+
+    xdg_surface_v5::xdg_surface_v5(struct ::xdg_surface_v5 *obj)
+        : m_xdg_surface(obj)
+    {
+        init_listener();
+    }
+
+    xdg_surface_v5::xdg_surface_v5()
+        : m_xdg_surface(nullptr)
+    {
+    }
+
+    xdg_surface_v5::~xdg_surface_v5()
+    {
+    }
+
+    void xdg_surface_v5::init(struct ::wl_registry *registry, int id, int version)
+    {
+        m_xdg_surface = static_cast<struct ::xdg_surface_v5 *>(wl_registry_bind(registry, id, &xdg_surface_v5_interface, version));
+        init_listener();
+    }
+
+    void xdg_surface_v5::init(struct ::xdg_surface_v5 *obj)
+    {
+        m_xdg_surface = obj;
+        init_listener();
+    }
+
+    bool xdg_surface_v5::isInitialized() const
+    {
+        return m_xdg_surface != nullptr;
+    }
+
+    const struct wl_interface *xdg_surface_v5::interface()
+    {
+        return &::xdg_surface_v5_interface;
+    }
+
+    void xdg_surface_v5::destroy()
+    {
+        xdg_surface_destroy(
+            m_xdg_surface);
+        m_xdg_surface = nullptr;
+    }
+
+    void xdg_surface_v5::set_parent(struct ::xdg_surface_v5 *parent)
+    {
+        xdg_surface_set_parent(
+            m_xdg_surface,
+            parent);
+    }
+
+    void xdg_surface_v5::set_title(const QString &title)
+    {
+        xdg_surface_set_title(
+            m_xdg_surface,
+            title.toUtf8().constData());
+    }
+
+    void xdg_surface_v5::set_app_id(const QString &app_id)
+    {
+        xdg_surface_set_app_id(
+            m_xdg_surface,
+            app_id.toUtf8().constData());
+    }
+
+    void xdg_surface_v5::show_window_menu(struct ::wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+    {
+        xdg_surface_show_window_menu(
+            m_xdg_surface,
+            seat,
+            serial,
+            x,
+            y);
+    }
+
+    void xdg_surface_v5::move(struct ::wl_seat *seat, uint32_t serial)
+    {
+        xdg_surface_move(
+            m_xdg_surface,
+            seat,
+            serial);
+    }
+
+    void xdg_surface_v5::resize(struct ::wl_seat *seat, uint32_t serial, uint32_t edges)
+    {
+        xdg_surface_resize(
+            m_xdg_surface,
+            seat,
+            serial,
+            edges);
+    }
+
+    void xdg_surface_v5::ack_configure(uint32_t serial)
+    {
+        xdg_surface_ack_configure(
+            m_xdg_surface,
+            serial);
+    }
+
+    void xdg_surface_v5::set_window_geometry(int32_t x, int32_t y, int32_t width, int32_t height)
+    {
+        xdg_surface_set_window_geometry(
+            m_xdg_surface,
+            x,
+            y,
+            width,
+            height);
+    }
+
+    void xdg_surface_v5::set_maximized()
+    {
+        xdg_surface_set_maximized(
+            m_xdg_surface);
+    }
+
+    void xdg_surface_v5::unset_maximized()
+    {
+        xdg_surface_unset_maximized(
+            m_xdg_surface);
+    }
+
+    void xdg_surface_v5::set_fullscreen(struct ::wl_output *output)
+    {
+        xdg_surface_set_fullscreen(
+            m_xdg_surface,
+            output);
+    }
+
+    void xdg_surface_v5::unset_fullscreen()
+    {
+        xdg_surface_unset_fullscreen(
+            m_xdg_surface);
+    }
+
+    void xdg_surface_v5::set_minimized()
+    {
+        xdg_surface_set_minimized(
+            m_xdg_surface);
+    }
+
+    void xdg_surface_v5::xdg_surface_configure(int32_t , int32_t , wl_array *, uint32_t )
+    {
+    }
+
+    void xdg_surface_v5::handle_configure(
+        void *data,
+        struct ::xdg_surface_v5 *object,
+        int32_t width,
+        int32_t height,
+        wl_array *states,
+        uint32_t serial)
+    {
+        Q_UNUSED(object);
+        static_cast<xdg_surface_v5 *>(data)->xdg_surface_configure(
+            width,
+            height,
+            states,
+            serial);
+    }
+
+    void xdg_surface_v5::xdg_surface_close()
+    {
+    }
+
+    void xdg_surface_v5::handle_close(
+        void *data,
+        struct ::xdg_surface_v5 *object)
+    {
+        Q_UNUSED(object);
+        static_cast<xdg_surface_v5 *>(data)->xdg_surface_close();
+    }
+
+    const struct xdg_surface_listener xdg_surface_v5::m_xdg_surface_listener = {
+        xdg_surface_v5::handle_configure,
+        xdg_surface_v5::handle_close
+    };
+
+    void xdg_surface_v5::init_listener()
+    {
+        xdg_surface_add_listener(m_xdg_surface, &m_xdg_surface_listener, this);
+    }
+
+    xdg_popup_v5::xdg_popup_v5(struct ::wl_registry *registry, int id, int version)
+    {
+        init(registry, id, version);
+    }
+
+    xdg_popup_v5::xdg_popup_v5(struct ::xdg_popup_v5 *obj)
+        : m_xdg_popup(obj)
+    {
+        init_listener();
+    }
+
+    xdg_popup_v5::xdg_popup_v5()
+        : m_xdg_popup(nullptr)
+    {
+    }
+
+    xdg_popup_v5::~xdg_popup_v5()
+    {
+    }
+
+    void xdg_popup_v5::init(struct ::wl_registry *registry, int id, int version)
+    {
+        m_xdg_popup = static_cast<struct ::xdg_popup_v5 *>(wl_registry_bind(registry, id, &xdg_popup_v5_interface, version));
+        init_listener();
+    }
+
+    void xdg_popup_v5::init(struct ::xdg_popup_v5 *obj)
+    {
+        m_xdg_popup = obj;
+        init_listener();
+    }
+
+    bool xdg_popup_v5::isInitialized() const
+    {
+        return m_xdg_popup != nullptr;
+    }
+
+    const struct wl_interface *xdg_popup_v5::interface()
+    {
+        return &::xdg_popup_v5_interface;
+    }
+
+    void xdg_popup_v5::destroy()
+    {
+        xdg_popup_destroy(
+            m_xdg_popup);
+        m_xdg_popup = nullptr;
+    }
+
+    void xdg_popup_v5::xdg_popup_popup_done()
+    {
+    }
+
+    void xdg_popup_v5::handle_popup_done(
+        void *data,
+        struct ::xdg_popup_v5 *object)
+    {
+        Q_UNUSED(object);
+        static_cast<xdg_popup_v5 *>(data)->xdg_popup_popup_done();
+    }
+
+    const struct xdg_popup_listener xdg_popup_v5::m_xdg_popup_listener = {
+        xdg_popup_v5::handle_popup_done
+    };
+
+    void xdg_popup_v5::init_listener()
+    {
+        xdg_popup_add_listener(m_xdg_popup, &m_xdg_popup_listener, this);
+    }
+}
+
+QT_WARNING_POP
+QT_END_NAMESPACE
diff --git a/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5_p.h b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5_p.h
new file mode 100644
index 000000000..3d8a6c13d
--- /dev/null
+++ b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/qwayland-xdg-shell-unstable-v5_p.h
@@ -0,0 +1,198 @@
+// Hand-edited to resolve conflicts with xdg-shell stable
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#ifndef QT_WAYLAND_XDG_SHELL_UNSTABLE_V5
+#define QT_WAYLAND_XDG_SHELL_UNSTABLE_V5
+
+#include "wayland-xdg-shell-unstable-v5-client-protocol_p.h"
+#include <QByteArray>
+#include <QString>
+
+QT_BEGIN_NAMESPACE
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Wmissing-field-initializers")
+
+namespace QtWayland {
+    class  xdg_shell_v5
+    {
+    public:
+        xdg_shell_v5(struct ::wl_registry *registry, int id, int version);
+        xdg_shell_v5(struct ::xdg_shell_v5 *object);
+        xdg_shell_v5();
+
+        virtual ~xdg_shell_v5();
+
+        void init(struct ::wl_registry *registry, int id, int version);
+        void init(struct ::xdg_shell_v5 *object);
+
+        struct ::xdg_shell_v5 *object() { return m_xdg_shell; }
+        const struct ::xdg_shell_v5 *object() const { return m_xdg_shell; }
+
+        bool isInitialized() const;
+
+        static const struct ::wl_interface *interface();
+
+        enum version {
+            version_current = 5 // Always the latest version
+        };
+
+        enum error {
+            error_role = 0, // given wl_surface has another role
+            error_defunct_surfaces = 1, // xdg_shell was destroyed before children
+            error_not_the_topmost_popup = 2, // the client tried to map or destroy a non-topmost popup
+            error_invalid_popup_parent = 3 // the client specified an invalid popup parent surface
+        };
+
+        void destroy();
+        void use_unstable_version(int32_t version);
+        struct ::xdg_surface_v5 *get_xdg_surface(struct ::wl_surface *surface);
+        struct ::xdg_popup_v5 *get_xdg_popup(struct ::wl_surface *surface, struct ::wl_surface *parent, struct ::wl_seat *seat, uint32_t serial, int32_t x, int32_t y);
+        void pong(uint32_t serial);
+
+    protected:
+        virtual void xdg_shell_ping(uint32_t serial);
+
+    private:
+        void init_listener();
+        static const struct xdg_shell_listener m_xdg_shell_listener;
+        static void handle_ping(
+            void *data,
+            struct ::xdg_shell_v5 *object,
+            uint32_t serial);
+        struct ::xdg_shell_v5 *m_xdg_shell;
+    };
+
+    class  xdg_surface_v5
+    {
+    public:
+        xdg_surface_v5(struct ::wl_registry *registry, int id, int version);
+        xdg_surface_v5(struct ::xdg_surface_v5 *object);
+        xdg_surface_v5();
+
+        virtual ~xdg_surface_v5();
+
+        void init(struct ::wl_registry *registry, int id, int version);
+        void init(struct ::xdg_surface_v5 *object);
+
+        struct ::xdg_surface_v5 *object() { return m_xdg_surface; }
+        const struct ::xdg_surface_v5 *object() const { return m_xdg_surface; }
+
+        bool isInitialized() const;
+
+        static const struct ::wl_interface *interface();
+
+        enum resize_edge {
+            resize_edge_none = 0,
+            resize_edge_top = 1,
+            resize_edge_bottom = 2,
+            resize_edge_left = 4,
+            resize_edge_top_left = 5,
+            resize_edge_bottom_left = 6,
+            resize_edge_right = 8,
+            resize_edge_top_right = 9,
+            resize_edge_bottom_right = 10
+        };
+
+        enum state {
+            state_maximized = 1, // the surface is maximized
+            state_fullscreen = 2, // the surface is fullscreen
+            state_resizing = 3,
+            state_activated = 4
+        };
+
+        void destroy();
+        void set_parent(struct ::xdg_surface_v5 *parent);
+        void set_title(const QString &title);
+        void set_app_id(const QString &app_id);
+        void show_window_menu(struct ::wl_seat *seat, uint32_t serial, int32_t x, int32_t y);
+        void move(struct ::wl_seat *seat, uint32_t serial);
+        void resize(struct ::wl_seat *seat, uint32_t serial, uint32_t edges);
+        void ack_configure(uint32_t serial);
+        void set_window_geometry(int32_t x, int32_t y, int32_t width, int32_t height);
+        void set_maximized();
+        void unset_maximized();
+        void set_fullscreen(struct ::wl_output *output);
+        void unset_fullscreen();
+        void set_minimized();
+
+    protected:
+        virtual void xdg_surface_configure(int32_t width, int32_t height, wl_array *states, uint32_t serial);
+        virtual void xdg_surface_close();
+
+    private:
+        void init_listener();
+        static const struct xdg_surface_listener m_xdg_surface_listener;
+        static void handle_configure(
+            void *data,
+            struct ::xdg_surface_v5 *object,
+            int32_t width,
+            int32_t height,
+            wl_array *states,
+            uint32_t serial);
+        static void handle_close(
+            void *data,
+            struct ::xdg_surface_v5 *object);
+        struct ::xdg_surface_v5 *m_xdg_surface;
+    };
+
+    class  xdg_popup_v5
+    {
+    public:
+        xdg_popup_v5(struct ::wl_registry *registry, int id, int version);
+        xdg_popup_v5(struct ::xdg_popup_v5 *object);
+        xdg_popup_v5();
+
+        virtual ~xdg_popup_v5();
+
+        void init(struct ::wl_registry *registry, int id, int version);
+        void init(struct ::xdg_popup_v5 *object);
+
+        struct ::xdg_popup_v5 *object() { return m_xdg_popup; }
+        const struct ::xdg_popup_v5 *object() const { return m_xdg_popup; }
+
+        bool isInitialized() const;
+
+        static const struct ::wl_interface *interface();
+
+        void destroy();
+
+    protected:
+        virtual void xdg_popup_popup_done();
+
+    private:
+        void init_listener();
+        static const struct xdg_popup_listener m_xdg_popup_listener;
+        static void handle_popup_done(
+            void *data,
+            struct ::xdg_popup_v5 *object);
+        struct ::xdg_popup_v5 *m_xdg_popup;
+    };
+}
+
+QT_WARNING_POP
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-client-protocol_p.h b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-client-protocol_p.h
new file mode 100644
index 000000000..62b6a7858
--- /dev/null
+++ b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-client-protocol_p.h
@@ -0,0 +1,1112 @@
+/* Generated by wayland-scanner 1.13.0 */
+// Hand-edited to resolve conflicts with xdg-shell stable
+
+#ifndef XDG_SHELL_UNSTABLE_V5_CLIENT_PROTOCOL_H
+#define XDG_SHELL_UNSTABLE_V5_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_shell_unstable_v5 The xdg_shell_unstable_v5 protocol
+ * @section page_ifaces_xdg_shell_unstable_v5 Interfaces
+ * - @subpage page_iface_xdg_shell_v5 - create desktop-style surfaces
+ * - @subpage page_iface_xdg_surface_v5 - A desktop window
+ * - @subpage page_iface_xdg_popup_v5 - short-lived, popup surfaces for menus
+ * @section page_copyright_xdg_shell_unstable_v5 Copyright
+ * <pre>
+ *
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_output;
+struct wl_seat;
+struct wl_surface;
+struct xdg_popup_v5;
+struct xdg_shell_v5;
+struct xdg_surface_v5;
+
+/**
+ * @page page_iface_xdg_shell_v5 xdg_shell
+ * @section page_iface_xdg_shell_desc Description
+ *
+ * xdg_shell_v5 allows clients to turn a wl_surface into a "real window"
+ * which can be dragged, resized, stacked, and moved around by the
+ * user. Everything about this interface is suited towards traditional
+ * desktop environments.
+ * @section page_iface_xdg_shell_api API
+ * See @ref iface_xdg_shell.
+ */
+/**
+ * @defgroup iface_xdg_shell_v5 The xdg_shell_v5 interface
+ *
+ * xdg_shell_v5 allows clients to turn a wl_surface into a "real window"
+ * which can be dragged, resized, stacked, and moved around by the
+ * user. Everything about this interface is suited towards traditional
+ * desktop environments.
+ */
+extern const struct wl_interface xdg_shell_v5_interface;
+/**
+ * @page page_iface_xdg_surface_v5 xdg_surface
+ * @section page_iface_xdg_surface_desc Description
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides requests to treat surfaces like windows, allowing to set
+ * properties like maximized, fullscreen, minimized, and to move and resize
+ * them, and associate metadata like title and app id.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface_v5 state to take effect. Prior to committing the new
+ * state, it can set up initial configuration, such as maximizing or setting
+ * a window geometry.
+ *
+ * Even without attaching a buffer the compositor must respond to initial
+ * committed configuration, for instance sending a configure event with
+ * expected window geometry if the client maximized its surface during
+ * initialization.
+ *
+ * For a surface to be mapped by the compositor the client must have
+ * committed both an xdg_surface_v5 state and a buffer.
+ * @section page_iface_xdg_surface_api API
+ * See @ref iface_xdg_surface.
+ */
+/**
+ * @defgroup iface_xdg_surface_v5 The xdg_surface_v5 interface
+ *
+ * An interface that may be implemented by a wl_surface, for
+ * implementations that provide a desktop-style user interface.
+ *
+ * It provides requests to treat surfaces like windows, allowing to set
+ * properties like maximized, fullscreen, minimized, and to move and resize
+ * them, and associate metadata like title and app id.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_surface_v5 state to take effect. Prior to committing the new
+ * state, it can set up initial configuration, such as maximizing or setting
+ * a window geometry.
+ *
+ * Even without attaching a buffer the compositor must respond to initial
+ * committed configuration, for instance sending a configure event with
+ * expected window geometry if the client maximized its surface during
+ * initialization.
+ *
+ * For a surface to be mapped by the compositor the client must have
+ * committed both an xdg_surface_v5 state and a buffer.
+ */
+extern const struct wl_interface xdg_surface_v5_interface;
+/**
+ * @page page_iface_xdg_popup_v5 xdg_popup
+ * @section page_iface_xdg_popup_desc Description
+ *
+ * A popup surface is a short-lived, temporary surface that can be
+ * used to implement menus. It takes an explicit grab on the surface
+ * that will be dismissed when the user dismisses the popup. This can
+ * be done by the user clicking outside the surface, using the keyboard,
+ * or even locking the screen through closing the lid or a timeout.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out,
+ * and at the same time the surface will be unmapped. The xdg_popup
+ * object is now inert and cannot be reactivated, so clients should
+ * destroy it. Explicitly destroying the xdg_popup_v5 object will also
+ * dismiss the popup and unmap the surface.
+ *
+ * Clients will receive events for all their surfaces during this
+ * grab (which is an "owner-events" grab in X11 parlance). This is
+ * done so that users can navigate through submenus and other
+ * "nested" popup windows without having to dismiss the topmost
+ * popup.
+ *
+ * Clients that want to dismiss the popup when another surface of
+ * their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * The parent surface must have either an xdg_surface_v5 or xdg_popup
+ * role.
+ *
+ * Specifying an xdg_popup_v5 for the parent means that the popups are
+ * nested, with this popup now being the topmost popup. Nested
+ * popups must be destroyed in the reverse order they were created
+ * in, e.g. the only popup you are allowed to destroy at all times
+ * is the topmost one.
+ *
+ * If there is an existing popup when creating a new popup, the
+ * parent must be the current topmost popup.
+ *
+ * A parent surface must be mapped before the new popup is mapped.
+ *
+ * When compositors choose to dismiss a popup, they will likely
+ * dismiss every nested popup as well. When a compositor dismisses
+ * popups, it will follow the same dismissing order as required
+ * from the client.
+ *
+ * The x and y arguments passed when creating the popup object specify
+ * where the top left of the popup should be placed, relative to the
+ * local surface coordinates of the parent surface. See
+ * xdg_shell.get_xdg_popup.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup_v5 state to take effect.
+ *
+ * For a surface to be mapped by the compositor the client must have
+ * committed both the xdg_popup_v5 state and a buffer.
+ * @section page_iface_xdg_popup_api API
+ * See @ref iface_xdg_popup.
+ */
+/**
+ * @defgroup iface_xdg_popup_v5 The xdg_popup_v5 interface
+ *
+ * A popup surface is a short-lived, temporary surface that can be
+ * used to implement menus. It takes an explicit grab on the surface
+ * that will be dismissed when the user dismisses the popup. This can
+ * be done by the user clicking outside the surface, using the keyboard,
+ * or even locking the screen through closing the lid or a timeout.
+ *
+ * When the popup is dismissed, a popup_done event will be sent out,
+ * and at the same time the surface will be unmapped. The xdg_popup
+ * object is now inert and cannot be reactivated, so clients should
+ * destroy it. Explicitly destroying the xdg_popup_v5 object will also
+ * dismiss the popup and unmap the surface.
+ *
+ * Clients will receive events for all their surfaces during this
+ * grab (which is an "owner-events" grab in X11 parlance). This is
+ * done so that users can navigate through submenus and other
+ * "nested" popup windows without having to dismiss the topmost
+ * popup.
+ *
+ * Clients that want to dismiss the popup when another surface of
+ * their own is clicked should dismiss the popup using the destroy
+ * request.
+ *
+ * The parent surface must have either an xdg_surface_v5 or xdg_popup
+ * role.
+ *
+ * Specifying an xdg_popup_v5 for the parent means that the popups are
+ * nested, with this popup now being the topmost popup. Nested
+ * popups must be destroyed in the reverse order they were created
+ * in, e.g. the only popup you are allowed to destroy at all times
+ * is the topmost one.
+ *
+ * If there is an existing popup when creating a new popup, the
+ * parent must be the current topmost popup.
+ *
+ * A parent surface must be mapped before the new popup is mapped.
+ *
+ * When compositors choose to dismiss a popup, they will likely
+ * dismiss every nested popup as well. When a compositor dismisses
+ * popups, it will follow the same dismissing order as required
+ * from the client.
+ *
+ * The x and y arguments passed when creating the popup object specify
+ * where the top left of the popup should be placed, relative to the
+ * local surface coordinates of the parent surface. See
+ * xdg_shell.get_xdg_popup.
+ *
+ * The client must call wl_surface.commit on the corresponding wl_surface
+ * for the xdg_popup_v5 state to take effect.
+ *
+ * For a surface to be mapped by the compositor the client must have
+ * committed both the xdg_popup_v5 state and a buffer.
+ */
+extern const struct wl_interface xdg_popup_v5_interface;
+
+#ifndef XDG_SHELL_VERSION_ENUM
+#define XDG_SHELL_VERSION_ENUM
+/**
+ * @ingroup iface_xdg_shell
+ * latest protocol version
+ *
+ * The 'current' member of this enum gives the version of the
+ * protocol.  Implementations can compare this to the version
+ * they implement using static_assert to ensure the protocol and
+ * implementation versions match.
+ */
+enum xdg_shell_version {
+	/**
+	 * Always the latest version
+	 */
+	XDG_SHELL_VERSION_CURRENT = 5,
+};
+#endif /* XDG_SHELL_VERSION_ENUM */
+
+#ifndef XDG_SHELL_ERROR_ENUM
+#define XDG_SHELL_ERROR_ENUM
+enum xdg_shell_error {
+	/**
+	 * given wl_surface has another role
+	 */
+	XDG_SHELL_ERROR_ROLE = 0,
+	/**
+	 * xdg_shell_v5 was destroyed before children
+	 */
+	XDG_SHELL_ERROR_DEFUNCT_SURFACES = 1,
+	/**
+	 * the client tried to map or destroy a non-topmost popup
+	 */
+	XDG_SHELL_ERROR_NOT_THE_TOPMOST_POPUP = 2,
+	/**
+	 * the client specified an invalid popup parent surface
+	 */
+	XDG_SHELL_ERROR_INVALID_POPUP_PARENT = 3,
+};
+#endif /* XDG_SHELL_ERROR_ENUM */
+
+/**
+ * @ingroup iface_xdg_shell
+ * @struct xdg_shell_listener
+ */
+struct xdg_shell_listener {
+	/**
+	 * check if the client is alive
+	 *
+	 * The ping event asks the client if it's still alive. Pass the
+	 * serial specified in the event back to the compositor by sending
+	 * a "pong" request back with the specified serial.
+	 *
+	 * Compositors can use this to determine if the client is still
+	 * alive. It's unspecified what will happen if the client doesn't
+	 * respond to the ping request, or in what timeframe. Clients
+	 * should try to respond in a reasonable amount of time.
+	 *
+	 * A compositor is free to ping in any way it wants, but a client
+	 * must always respond to any xdg_shell_v5 object it created.
+	 * @param serial pass this to the pong request
+	 */
+	void (*ping)(void *data,
+                     struct xdg_shell_v5 *xdg_shell_v5,
+		     uint32_t serial);
+};
+
+/**
+ * @ingroup iface_xdg_shell
+ */
+static inline int
+xdg_shell_add_listener(struct xdg_shell_v5 *xdg_shell,
+		       const struct xdg_shell_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) xdg_shell,
+				     (void (**)(void)) listener, data);
+}
+
+#define XDG_SHELL_DESTROY 0
+#define XDG_SHELL_USE_UNSTABLE_VERSION 1
+#define XDG_SHELL_GET_XDG_SURFACE 2
+#define XDG_SHELL_GET_XDG_POPUP 3
+#define XDG_SHELL_PONG 4
+
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_PING_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_USE_UNSTABLE_VERSION_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_GET_XDG_SURFACE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_GET_XDG_POPUP_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_shell
+ */
+#define XDG_SHELL_PONG_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_shell_v5 */
+static inline void
+xdg_shell_set_user_data(struct xdg_shell_v5 *xdg_shell, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) xdg_shell, user_data);
+}
+
+/** @ingroup iface_xdg_shell_v5 */
+static inline void *
+xdg_shell_get_user_data(struct xdg_shell_v5 *xdg_shell)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) xdg_shell);
+}
+
+static inline uint32_t
+xdg_shell_get_version(struct xdg_shell_v5 *xdg_shell)
+{
+	return wl_proxy_get_version((struct wl_proxy *) xdg_shell);
+}
+
+/**
+ * @ingroup iface_xdg_shell
+ *
+ * Destroy this xdg_shell_v5 object.
+ *
+ * Destroying a bound xdg_shell_v5 object while there are surfaces
+ * still alive created by this xdg_shell_v5 object instance is illegal
+ * and will result in a protocol error.
+ */
+static inline void
+xdg_shell_destroy(struct xdg_shell_v5 *xdg_shell)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_shell,
+			 XDG_SHELL_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) xdg_shell);
+}
+
+/**
+ * @ingroup iface_xdg_shell
+ *
+ * Negotiate the unstable version of the interface.  This
+ * mechanism is in place to ensure client and server agree on the
+ * unstable versions of the protocol that they speak or exit
+ * cleanly if they don't agree.  This request will go away once
+ * the xdg-shell protocol is stable.
+ */
+static inline void
+xdg_shell_use_unstable_version(struct xdg_shell_v5 *xdg_shell, int32_t version)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_shell,
+			 XDG_SHELL_USE_UNSTABLE_VERSION, version);
+}
+
+/**
+ * @ingroup iface_xdg_shell
+ *
+ * This creates an xdg_surface_v5 for the given surface and gives it the
+ * xdg_surface_v5 role. A wl_surface can only be given an xdg_surface_v5 role
+ * once. If get_xdg_surface_v5 is called with a wl_surface that already has
+ * an active xdg_surface_v5 associated with it, or if it had any other role,
+ * an error is raised.
+ *
+ * See the documentation of xdg_surface_v5 for more details about what an
+ * xdg_surface_v5 is and how it is used.
+ */
+static inline struct xdg_surface_v5 *
+xdg_shell_get_xdg_surface(struct xdg_shell_v5 *xdg_shell, struct wl_surface *surface)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_constructor((struct wl_proxy *) xdg_shell,
+                         XDG_SHELL_GET_XDG_SURFACE, &xdg_surface_v5_interface, NULL, surface);
+
+	return (struct xdg_surface_v5 *) id;
+}
+
+/**
+ * @ingroup iface_xdg_shell
+ *
+ * This creates an xdg_popup_v5 for the given surface and gives it the
+ * xdg_popup_v5 role. A wl_surface can only be given an xdg_popup_v5 role
+ * once. If get_xdg_popup_v5 is called with a wl_surface that already has
+ * an active xdg_popup_v5 associated with it, or if it had any other role,
+ * an error is raised.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event.
+ *
+ * See the documentation of xdg_popup_v5 for more details about what an
+ * xdg_popup_v5 is and how it is used.
+ */
+static inline struct xdg_popup_v5 *
+xdg_shell_get_xdg_popup(struct xdg_shell_v5 *xdg_shell, struct wl_surface *surface, struct wl_surface *parent, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_constructor((struct wl_proxy *) xdg_shell,
+                         XDG_SHELL_GET_XDG_POPUP, &xdg_popup_v5_interface, NULL, surface, parent, seat, serial, x, y);
+
+	return (struct xdg_popup_v5 *) id;
+}
+
+/**
+ * @ingroup iface_xdg_shell
+ *
+ * A client must respond to a ping event with a pong request or
+ * the client may be deemed unresponsive.
+ */
+static inline void
+xdg_shell_pong(struct xdg_shell_v5 *xdg_shell, uint32_t serial)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_shell,
+			 XDG_SHELL_PONG, serial);
+}
+
+#ifndef XDG_SURFACE_RESIZE_EDGE_ENUM
+#define XDG_SURFACE_RESIZE_EDGE_ENUM
+/**
+ * @ingroup iface_xdg_surface
+ * edge values for resizing
+ *
+ * These values are used to indicate which edge of a surface
+ * is being dragged in a resize operation.
+ */
+enum xdg_surface_resize_edge {
+	XDG_SURFACE_RESIZE_EDGE_NONE = 0,
+	XDG_SURFACE_RESIZE_EDGE_TOP = 1,
+	XDG_SURFACE_RESIZE_EDGE_BOTTOM = 2,
+	XDG_SURFACE_RESIZE_EDGE_LEFT = 4,
+	XDG_SURFACE_RESIZE_EDGE_TOP_LEFT = 5,
+	XDG_SURFACE_RESIZE_EDGE_BOTTOM_LEFT = 6,
+	XDG_SURFACE_RESIZE_EDGE_RIGHT = 8,
+	XDG_SURFACE_RESIZE_EDGE_TOP_RIGHT = 9,
+	XDG_SURFACE_RESIZE_EDGE_BOTTOM_RIGHT = 10,
+};
+#endif /* XDG_SURFACE_RESIZE_EDGE_ENUM */
+
+#ifndef XDG_SURFACE_STATE_ENUM
+#define XDG_SURFACE_STATE_ENUM
+/**
+ * @ingroup iface_xdg_surface
+ * types of state on the surface
+ *
+ * The different state values used on the surface. This is designed for
+ * state values like maximized, fullscreen. It is paired with the
+ * configure event to ensure that both the client and the compositor
+ * setting the state can be synchronized.
+ *
+ * States set in this way are double-buffered. They will get applied on
+ * the next commit.
+ *
+ * Desktop environments may extend this enum by taking up a range of
+ * values and documenting the range they chose in this description.
+ * They are not required to document the values for the range that they
+ * chose. Ideally, any good extensions from a desktop environment should
+ * make its way into standardization into this enum.
+ *
+ * The current reserved ranges are:
+ *
+ * 0x0000 - 0x0FFF: xdg-shell core values, documented below.
+ * 0x1000 - 0x1FFF: GNOME
+ */
+enum xdg_surface_state {
+	/**
+	 * the surface is maximized
+	 */
+	XDG_SURFACE_STATE_MAXIMIZED = 1,
+	/**
+	 * the surface is fullscreen
+	 */
+	XDG_SURFACE_STATE_FULLSCREEN = 2,
+	XDG_SURFACE_STATE_RESIZING = 3,
+	XDG_SURFACE_STATE_ACTIVATED = 4,
+};
+#endif /* XDG_SURFACE_STATE_ENUM */
+
+/**
+ * @ingroup iface_xdg_surface
+ * @struct xdg_surface_listener
+ */
+struct xdg_surface_listener {
+	/**
+	 * suggest a surface change
+	 *
+	 * The configure event asks the client to resize its surface or
+	 * to change its state.
+	 *
+	 * The width and height arguments specify a hint to the window
+	 * about how its surface should be resized in window geometry
+	 * coordinates. See set_window_geometry.
+	 *
+	 * If the width or height arguments are zero, it means the client
+	 * should decide its own window dimension. This may happen when the
+	 * compositor need to configure the state of the surface but
+	 * doesn't have any information about any previous or expected
+	 * dimension.
+	 *
+	 * The states listed in the event specify how the width/height
+	 * arguments should be interpreted, and possibly how it should be
+	 * drawn.
+	 *
+	 * Clients should arrange their surface for the new size and
+	 * states, and then send a ack_configure request with the serial
+	 * sent in this configure event at some point before committing the
+	 * new surface.
+	 *
+	 * If the client receives multiple configure events before it can
+	 * respond to one, it is free to discard all but the last event it
+	 * received.
+	 */
+	void (*configure)(void *data,
+			  struct xdg_surface_v5 *xdg_surface_v5,
+			  int32_t width,
+			  int32_t height,
+			  struct wl_array *states,
+			  uint32_t serial);
+	/**
+	 * surface wants to be closed
+	 *
+	 * The close event is sent by the compositor when the user wants
+	 * the surface to be closed. This should be equivalent to the user
+	 * clicking the close button in client-side decorations, if your
+	 * application has any...
+	 *
+	 * This is only a request that the user intends to close your
+	 * window. The client may choose to ignore this request, or show a
+	 * dialog to ask the user to save their data...
+	 */
+	void (*close)(void *data,
+		      struct xdg_surface_v5 *xdg_surface_v5);
+};
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+static inline int
+xdg_surface_add_listener(struct xdg_surface_v5 *xdg_surface,
+			 const struct xdg_surface_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) xdg_surface,
+				     (void (**)(void)) listener, data);
+}
+
+#define XDG_SURFACE_DESTROY 0
+#define XDG_SURFACE_SET_PARENT 1
+#define XDG_SURFACE_SET_TITLE 2
+#define XDG_SURFACE_SET_APP_ID 3
+#define XDG_SURFACE_SHOW_WINDOW_MENU 4
+#define XDG_SURFACE_MOVE 5
+#define XDG_SURFACE_RESIZE 6
+#define XDG_SURFACE_ACK_CONFIGURE 7
+#define XDG_SURFACE_SET_WINDOW_GEOMETRY 8
+#define XDG_SURFACE_SET_MAXIMIZED 9
+#define XDG_SURFACE_UNSET_MAXIMIZED 10
+#define XDG_SURFACE_SET_FULLSCREEN 11
+#define XDG_SURFACE_UNSET_FULLSCREEN 12
+#define XDG_SURFACE_SET_MINIMIZED 13
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_CLOSE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_PARENT_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_TITLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_APP_ID_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SHOW_WINDOW_MENU_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_MOVE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_RESIZE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_ACK_CONFIGURE_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_UNSET_MAXIMIZED_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_UNSET_FULLSCREEN_SINCE_VERSION 1
+/**
+ * @ingroup iface_xdg_surface
+ */
+#define XDG_SURFACE_SET_MINIMIZED_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_surface_v5 */
+static inline void
+xdg_surface_set_user_data(struct xdg_surface_v5 *xdg_surface, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) xdg_surface, user_data);
+}
+
+/** @ingroup iface_xdg_surface_v5 */
+static inline void *
+xdg_surface_get_user_data(struct xdg_surface_v5 *xdg_surface)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) xdg_surface);
+}
+
+static inline uint32_t
+xdg_surface_get_version(struct xdg_surface_v5 *xdg_surface)
+{
+	return wl_proxy_get_version((struct wl_proxy *) xdg_surface);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Unmap and destroy the window. The window will be effectively
+ * hidden from the user's point of view, and all state like
+ * maximization, fullscreen, and so on, will be lost.
+ */
+static inline void
+xdg_surface_destroy(struct xdg_surface_v5 *xdg_surface)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) xdg_surface);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Set the "parent" of this surface. This window should be stacked
+ * above a parent. The parent surface must be mapped as long as this
+ * surface is mapped.
+ *
+ * Parent windows should be set on dialogs, toolboxes, or other
+ * "auxiliary" surfaces, so that the parent is raised when the dialog
+ * is raised.
+ */
+static inline void
+xdg_surface_set_parent(struct xdg_surface_v5 *xdg_surface, struct xdg_surface_v5 *parent)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_PARENT, parent);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Set a short title for the surface.
+ *
+ * This string may be used to identify the surface in a task bar,
+ * window list, or other user interface elements provided by the
+ * compositor.
+ *
+ * The string must be encoded in UTF-8.
+ */
+static inline void
+xdg_surface_set_title(struct xdg_surface_v5 *xdg_surface, const char *title)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_TITLE, title);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Set an application identifier for the surface.
+ *
+ * The app ID identifies the general class of applications to which
+ * the surface belongs. The compositor can use this to group multiple
+ * surfaces together, or to determine how to launch a new application.
+ *
+ * For D-Bus activatable applications, the app ID is used as the D-Bus
+ * service name.
+ *
+ * The compositor shell will try to group application surfaces together
+ * by their app ID.  As a best practice, it is suggested to select app
+ * ID's that match the basename of the application's .desktop file.
+ * For example, "org.freedesktop.FooViewer" where the .desktop file is
+ * "org.freedesktop.FooViewer.desktop".
+ *
+ * See the desktop-entry specification [0] for more details on
+ * application identifiers and how they relate to well-known D-Bus
+ * names and .desktop files.
+ *
+ * [0] http://standards.freedesktop.org/desktop-entry-spec/
+ */
+static inline void
+xdg_surface_set_app_id(struct xdg_surface_v5 *xdg_surface, const char *app_id)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_APP_ID, app_id);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Clients implementing client-side decorations might want to show
+ * a context menu when right-clicking on the decorations, giving the
+ * user a menu that they can use to maximize or minimize the window.
+ *
+ * This request asks the compositor to pop up such a window menu at
+ * the given position, relative to the local surface coordinates of
+ * the parent surface. There are no guarantees as to what menu items
+ * the window menu contains.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event.
+ */
+static inline void
+xdg_surface_show_window_menu(struct xdg_surface_v5 *xdg_surface, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SHOW_WINDOW_MENU, seat, serial, x, y);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Start an interactive, user-driven move of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive move (touch,
+ * pointer, etc).
+ *
+ * The server may ignore move requests depending on the state of
+ * the surface (e.g. fullscreen or maximized), or if the passed serial
+ * is no longer valid.
+ *
+ * If triggered, the surface will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the move. It is up to the
+ * compositor to visually indicate that the move is taking place, such as
+ * updating a pointer cursor, during the move. There is no guarantee
+ * that the device focus will return when the move is completed.
+ */
+static inline void
+xdg_surface_move(struct xdg_surface_v5 *xdg_surface, struct wl_seat *seat, uint32_t serial)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_MOVE, seat, serial);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Start a user-driven, interactive resize of the surface.
+ *
+ * This request must be used in response to some sort of user action
+ * like a button press, key press, or touch down event. The passed
+ * serial is used to determine the type of interactive resize (touch,
+ * pointer, etc).
+ *
+ * The server may ignore resize requests depending on the state of
+ * the surface (e.g. fullscreen or maximized).
+ *
+ * If triggered, the client will receive configure events with the
+ * "resize" state enum value and the expected sizes. See the "resize"
+ * enum value for more details about what is required. The client
+ * must also acknowledge configure events using "ack_configure". After
+ * the resize is completed, the client will receive another "configure"
+ * event without the resize state.
+ *
+ * If triggered, the surface also will lose the focus of the device
+ * (wl_pointer, wl_touch, etc) used for the resize. It is up to the
+ * compositor to visually indicate that the resize is taking place,
+ * such as updating a pointer cursor, during the resize. There is no
+ * guarantee that the device focus will return when the resize is
+ * completed.
+ *
+ * The edges parameter specifies how the surface should be resized,
+ * and is one of the values of the resize_edge enum. The compositor
+ * may use this information to update the surface position for
+ * example when dragging the top left corner. The compositor may also
+ * use this information to adapt its behavior, e.g. choose an
+ * appropriate cursor image.
+ */
+static inline void
+xdg_surface_resize(struct xdg_surface_v5 *xdg_surface, struct wl_seat *seat, uint32_t serial, uint32_t edges)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_RESIZE, seat, serial, edges);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * When a configure event is received, if a client commits the
+ * surface in response to the configure event, then the client
+ * must make a ack_configure request before the commit request,
+ * passing along the serial of the configure event.
+ *
+ * For instance, the compositor might use this information to move
+ * a surface to the top left only when the client has drawn itself
+ * for the maximized or fullscreen state.
+ *
+ * If the client receives multiple configure events before it
+ * can respond to one, it only has to ack the last configure event.
+ */
+static inline void
+xdg_surface_ack_configure(struct xdg_surface_v5 *xdg_surface, uint32_t serial)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_ACK_CONFIGURE, serial);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * The window geometry of a window is its "visible bounds" from the
+ * user's perspective. Client-side decorations often have invisible
+ * portions like drop-shadows which should be ignored for the
+ * purposes of aligning, placing and constraining windows.
+ *
+ * The window geometry is double buffered, and will be applied at the
+ * time wl_surface.commit of the corresponding wl_surface is called.
+ *
+ * Once the window geometry of the surface is set once, it is not
+ * possible to unset it, and it will remain the same until
+ * set_window_geometry is called again, even if a new subsurface or
+ * buffer is attached.
+ *
+ * If never set, the value is the full bounds of the surface,
+ * including any subsurfaces. This updates dynamically on every
+ * commit. This unset mode is meant for extremely simple clients.
+ *
+ * If responding to a configure event, the window geometry in here
+ * must respect the sizing negotiations specified by the states in
+ * the configure event.
+ *
+ * The arguments are given in the surface local coordinate space of
+ * the wl_surface associated with this xdg_surface.
+ *
+ * The width and height must be greater than zero.
+ */
+static inline void
+xdg_surface_set_window_geometry(struct xdg_surface_v5 *xdg_surface, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_WINDOW_GEOMETRY, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Maximize the surface.
+ *
+ * After requesting that the surface should be maximized, the compositor
+ * will respond by emitting a configure event with the "maximized" state
+ * and the required window geometry. The client should then update its
+ * content, drawing it in a maximized state, i.e. without shadow or other
+ * decoration outside of the window geometry. The client must also
+ * acknowledge the configure when committing the new content (see
+ * ack_configure).
+ *
+ * It is up to the compositor to decide how and where to maximize the
+ * surface, for example which output and what region of the screen should
+ * be used.
+ *
+ * If the surface was already maximized, the compositor will still emit
+ * a configure event with the "maximized" state.
+ */
+static inline void
+xdg_surface_set_maximized(struct xdg_surface_v5 *xdg_surface)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_MAXIMIZED);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Unmaximize the surface.
+ *
+ * After requesting that the surface should be unmaximized, the compositor
+ * will respond by emitting a configure event without the "maximized"
+ * state. If available, the compositor will include the window geometry
+ * dimensions the window had prior to being maximized in the configure
+ * request. The client must then update its content, drawing it in a
+ * regular state, i.e. potentially with shadow, etc. The client must also
+ * acknowledge the configure when committing the new content (see
+ * ack_configure).
+ *
+ * It is up to the compositor to position the surface after it was
+ * unmaximized; usually the position the surface had before maximizing, if
+ * applicable.
+ *
+ * If the surface was already not maximized, the compositor will still
+ * emit a configure event without the "maximized" state.
+ */
+static inline void
+xdg_surface_unset_maximized(struct xdg_surface_v5 *xdg_surface)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_UNSET_MAXIMIZED);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Make the surface fullscreen.
+ *
+ * You can specify an output that you would prefer to be fullscreen.
+ * If this value is NULL, it's up to the compositor to choose which
+ * display will be used to map this surface.
+ *
+ * If the surface doesn't cover the whole output, the compositor will
+ * position the surface in the center of the output and compensate with
+ * black borders filling the rest of the output.
+ */
+static inline void
+xdg_surface_set_fullscreen(struct xdg_surface_v5 *xdg_surface, struct wl_output *output)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_FULLSCREEN, output);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ */
+static inline void
+xdg_surface_unset_fullscreen(struct xdg_surface_v5 *xdg_surface)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_UNSET_FULLSCREEN);
+}
+
+/**
+ * @ingroup iface_xdg_surface
+ *
+ * Request that the compositor minimize your surface. There is no
+ * way to know if the surface is currently minimized, nor is there
+ * any way to unset minimization on this surface.
+ *
+ * If you are looking to throttle redrawing when minimized, please
+ * instead use the wl_surface.frame event for this, as this will
+ * also work with live previews on windows in Alt-Tab, Expose or
+ * similar compositor features.
+ */
+static inline void
+xdg_surface_set_minimized(struct xdg_surface_v5 *xdg_surface)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_surface,
+			 XDG_SURFACE_SET_MINIMIZED);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ * @struct xdg_popup_listener
+ */
+struct xdg_popup_listener {
+	/**
+	 * popup interaction is done
+	 *
+	 * The popup_done event is sent out when a popup is dismissed by
+         * the compositor. The client should destroy the xdg_popup_v5 object
+	 * at this point.
+	 */
+	void (*popup_done)(void *data,
+			   struct xdg_popup_v5 *xdg_popup_v5);
+};
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+static inline int
+xdg_popup_add_listener(struct xdg_popup_v5 *xdg_popup,
+		       const struct xdg_popup_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) xdg_popup,
+				     (void (**)(void)) listener, data);
+}
+
+#define XDG_POPUP_DESTROY 0
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_POPUP_DONE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_xdg_popup
+ */
+#define XDG_POPUP_DESTROY_SINCE_VERSION 1
+
+/** @ingroup iface_xdg_popup_v5 */
+static inline void
+xdg_popup_set_user_data(struct xdg_popup_v5 *xdg_popup, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) xdg_popup, user_data);
+}
+
+/** @ingroup iface_xdg_popup_v5 */
+static inline void *
+xdg_popup_get_user_data(struct xdg_popup_v5 *xdg_popup)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) xdg_popup);
+}
+
+static inline uint32_t
+xdg_popup_get_version(struct xdg_popup_v5 *xdg_popup)
+{
+	return wl_proxy_get_version((struct wl_proxy *) xdg_popup);
+}
+
+/**
+ * @ingroup iface_xdg_popup
+ *
+ * This destroys the popup. Explicitly destroying the xdg_popup
+ * object will also dismiss the popup, and unmap the surface.
+ *
+ * If this xdg_popup_v5 is not the "topmost" popup, a protocol error
+ * will be sent.
+ */
+static inline void
+xdg_popup_destroy(struct xdg_popup_v5 *xdg_popup)
+{
+	wl_proxy_marshal((struct wl_proxy *) xdg_popup,
+			 XDG_POPUP_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) xdg_popup);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c
new file mode 100644
index 000000000..50a42437c
--- /dev/null
+++ b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c
@@ -0,0 +1,126 @@
+/* Generated by wayland-scanner 1.13.0 */
+// Hand-edited to resolve conflicts with xdg-shell stable
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_v5_interface;
+extern const struct wl_interface xdg_surface_v5_interface;
+
+static const struct wl_interface *types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+    &xdg_surface_v5_interface,
+	&wl_surface_interface,
+    &xdg_popup_v5_interface,
+	&wl_surface_interface,
+	&wl_surface_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+    &xdg_surface_v5_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_output_interface,
+};
+
+static const struct wl_message xdg_shell_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "use_unstable_version", "i", types + 0 },
+	{ "get_xdg_surface", "no", types + 4 },
+	{ "get_xdg_popup", "nooouii", types + 6 },
+	{ "pong", "u", types + 0 },
+};
+
+static const struct wl_message xdg_shell_events[] = {
+	{ "ping", "u", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_shell_v5_interface = {
+	"xdg_shell", 1,
+	5, xdg_shell_requests,
+	1, xdg_shell_events,
+};
+
+static const struct wl_message xdg_surface_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "set_parent", "?o", types + 13 },
+	{ "set_title", "s", types + 0 },
+	{ "set_app_id", "s", types + 0 },
+	{ "show_window_menu", "ouii", types + 14 },
+	{ "move", "ou", types + 18 },
+	{ "resize", "ouu", types + 20 },
+	{ "ack_configure", "u", types + 0 },
+	{ "set_window_geometry", "iiii", types + 0 },
+	{ "set_maximized", "", types + 0 },
+	{ "unset_maximized", "", types + 0 },
+	{ "set_fullscreen", "?o", types + 23 },
+	{ "unset_fullscreen", "", types + 0 },
+	{ "set_minimized", "", types + 0 },
+};
+
+static const struct wl_message xdg_surface_events[] = {
+	{ "configure", "iiau", types + 0 },
+	{ "close", "", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_surface_v5_interface = {
+	"xdg_surface", 1,
+	14, xdg_surface_requests,
+	2, xdg_surface_events,
+};
+
+static const struct wl_message xdg_popup_requests[] = {
+	{ "destroy", "", types + 0 },
+};
+
+static const struct wl_message xdg_popup_events[] = {
+	{ "popup_done", "", types + 0 },
+};
+
+WL_EXPORT const struct wl_interface xdg_popup_v5_interface = {
+	"xdg_popup", 1,
+	1, xdg_popup_requests,
+	1, xdg_popup_events,
+};
+
diff --git a/src/plugins/shellintegration/xdg-shell-v5/pregenerated/xdg-shell-v5.pri b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/xdg-shell-v5.pri
new file mode 100644
index 000000000..2990fd0f6
--- /dev/null
+++ b/src/plugins/shellintegration/xdg-shell-v5/pregenerated/xdg-shell-v5.pri
@@ -0,0 +1,12 @@
+# Putting pregenerated files in a 3rdparty directory to avoid
+# qtqa's license checking failing.
+
+HEADERS += \
+    $$PWD/3rdparty/qwayland-xdg-shell-unstable-v5_p.h \
+    $$PWD/3rdparty/wayland-xdg-shell-unstable-v5-client-protocol_p.h
+
+SOURCES += \
+    $$PWD/3rdparty/qwayland-xdg-shell-unstable-v5.cpp \
+    $$PWD/3rdparty/wayland-xdg-shell-unstable-v5-protocol.c
+
+INCLUDEPATH += $$PWD/3rdparty
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5.cpp b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5.cpp
index 539abcac7..85d25e3c0 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5.cpp
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5.cpp
@@ -47,9 +47,9 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWaylandClient {
 
-QWaylandXdgPopupV5::QWaylandXdgPopupV5(struct ::xdg_popup *popup, QWaylandWindow *window)
+QWaylandXdgPopupV5::QWaylandXdgPopupV5(struct ::xdg_popup_v5 *popup, QWaylandWindow *window)
     : QWaylandShellSurface(window)
-    , QtWayland::xdg_popup(popup)
+    , QtWayland::xdg_popup_v5(popup)
     , m_window(window)
 {
     if (window->display()->windowExtension())
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5_p.h b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5_p.h
index cb748c5cc..ff8e5639f 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5_p.h
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgpopupv5_p.h
@@ -51,7 +51,7 @@
 // We mean it.
 //
 
-#include "qwayland-xdg-shell-unstable-v5.h"
+#include "qwayland-xdg-shell-unstable-v5_p.h"
 
 #include <wayland-client.h>
 
@@ -68,11 +68,11 @@ class QWaylandWindow;
 class QWaylandExtendedSurface;
 
 class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgPopupV5 : public QWaylandShellSurface
-        , public QtWayland::xdg_popup
+        , public QtWayland::xdg_popup_v5
 {
     Q_OBJECT
 public:
-    QWaylandXdgPopupV5(struct ::xdg_popup *popup, QWaylandWindow *window);
+    QWaylandXdgPopupV5(struct ::xdg_popup_v5 *popup, QWaylandWindow *window);
     ~QWaylandXdgPopupV5() override;
 
 protected:
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp
index 6a693578c..4cbafbd71 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp
@@ -52,15 +52,10 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWaylandClient {
 
-QWaylandXdgShellV5::QWaylandXdgShellV5(struct ::xdg_shell *shell)
-    : QtWayland::xdg_shell(shell)
-{
-}
-
 QWaylandXdgShellV5::QWaylandXdgShellV5(struct ::wl_registry *registry, uint32_t id)
-    : QtWayland::xdg_shell(registry, id, 1)
+    : QtWayland::xdg_shell_v5(registry, id, 1)
 {
-    use_unstable_version(QtWayland::xdg_shell::version_current);
+    use_unstable_version(QtWayland::xdg_shell_v5::version_current);
 }
 
 QWaylandXdgShellV5::~QWaylandXdgShellV5()
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5_p.h b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5_p.h
index ec45bb32c..67e5d32a7 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5_p.h
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5_p.h
@@ -51,7 +51,7 @@
 // We mean it.
 //
 
-#include "qwayland-xdg-shell-unstable-v5.h"
+#include "qwayland-xdg-shell-unstable-v5_p.h"
 
 #include <QtCore/QSize>
 #include <QtCore/QVector>
@@ -72,10 +72,9 @@ class QWaylandInputDevice;
 class QWaylandXdgSurfaceV5;
 class QWaylandXdgPopupV5;
 
-class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgShellV5 : public QtWayland::xdg_shell
+class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgShellV5 : public QtWayland::xdg_shell_v5
 {
 public:
-    QWaylandXdgShellV5(struct ::xdg_shell *shell);
     QWaylandXdgShellV5(struct ::wl_registry *registry, uint32_t id);
     ~QWaylandXdgShellV5() override;
 
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5integration.cpp b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5integration.cpp
index 47d748b1c..d032002b1 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5integration.cpp
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5integration.cpp
@@ -51,6 +51,10 @@ namespace QtWaylandClient {
 
 bool QWaylandXdgShellV5Integration::initialize(QWaylandDisplay *display)
 {
+    qCWarning(lcQpaWayland) << "\"xdg-shell-v5\" is a deprecated shell extension, prefer using"
+                            << "\"xdg-shell-v6\" or \"xdg-shell\" if supported by the compositor"
+                            << "by setting the environment variable QT_WAYLAND_SHELL_INTEGRATION";
+
     Q_FOREACH (QWaylandDisplay::RegistryGlobal global, display->globals()) {
         if (global.interface == QLatin1String("xdg_shell")) {
             m_xdgShell.reset(new QWaylandXdgShellV5(display->wl_registry(), global.id));
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5.cpp b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5.cpp
index 40e2a994d..61a865cb2 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5.cpp
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5.cpp
@@ -54,7 +54,7 @@ namespace QtWaylandClient {
 
 QWaylandXdgSurfaceV5::QWaylandXdgSurfaceV5(QWaylandXdgShellV5 *shell, QWaylandWindow *window)
     : QWaylandShellSurface(window)
-    , QtWayland::xdg_surface(shell->get_xdg_surface(window->object()))
+    , QtWayland::xdg_surface_v5(shell->get_xdg_surface(window->object()))
     , m_window(window)
     , m_shell(shell)
 {
@@ -105,12 +105,12 @@ void QWaylandXdgSurfaceV5::updateTransientParent(QWaylandWindow *parent)
 
 void QWaylandXdgSurfaceV5::setTitle(const QString & title)
 {
-    return QtWayland::xdg_surface::set_title(title);
+    return QtWayland::xdg_surface_v5::set_title(title);
 }
 
 void QWaylandXdgSurfaceV5::setAppId(const QString & appId)
 {
-    return QtWayland::xdg_surface::set_app_id(appId);
+    return QtWayland::xdg_surface_v5::set_app_id(appId);
 }
 
 void QWaylandXdgSurfaceV5::raise()
diff --git a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5_p.h b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5_p.h
index e69433248..b938047ec 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5_p.h
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgsurfacev5_p.h
@@ -51,7 +51,7 @@
 // We mean it.
 //
 
-#include "qwayland-xdg-shell-unstable-v5.h"
+#include "qwayland-xdg-shell-unstable-v5_p.h"
 
 #include <QtWaylandClient/qtwaylandclientglobal.h>
 #include <QtWaylandClient/private/qwaylandshellsurface_p.h>
@@ -73,19 +73,19 @@ class QWaylandExtendedSurface;
 class QWaylandXdgShellV5;
 
 class Q_WAYLAND_CLIENT_EXPORT QWaylandXdgSurfaceV5 : public QWaylandShellSurface
-        , public QtWayland::xdg_surface
+        , public QtWayland::xdg_surface_v5
 {
     Q_OBJECT
 public:
     QWaylandXdgSurfaceV5(QWaylandXdgShellV5 *shell, QWaylandWindow *window);
     ~QWaylandXdgSurfaceV5() override;
 
-    using QtWayland::xdg_surface::resize;
+    using QtWayland::xdg_surface_v5::resize;
     void resize(QWaylandInputDevice *inputDevice, enum resize_edge edges);
 
     void resize(QWaylandInputDevice *inputDevice, enum wl_shell_surface_resize edges) override;
 
-    using QtWayland::xdg_surface::move;
+    using QtWayland::xdg_surface_v5::move;
     bool move(QWaylandInputDevice *inputDevice) override;
 
     void setTitle(const QString &title) override;
diff --git a/src/plugins/shellintegration/xdg-shell-v5/xdg-shell-v5.pro b/src/plugins/shellintegration/xdg-shell-v5/xdg-shell-v5.pro
index 0e97832e4..bf9edba78 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/xdg-shell-v5.pro
+++ b/src/plugins/shellintegration/xdg-shell-v5/xdg-shell-v5.pro
@@ -6,9 +6,6 @@ QMAKE_USE += wayland-client
 qtConfig(xkbcommon-evdev): \
     QMAKE_USE += xkbcommon_evdev
 
-WAYLANDCLIENTSOURCES += \
-    ../../../3rdparty/protocol/xdg-shell-unstable-v5.xml
-
 HEADERS += \
     qwaylandxdgpopupv5_p.h \
     qwaylandxdgshellv5_p.h \
@@ -22,6 +19,8 @@ SOURCES += \
     qwaylandxdgshellv5integration.cpp \
     qwaylandxdgsurfacev5.cpp \
 
+include (pregenerated/xdg-shell-v5.pri)
+
 OTHER_FILES += \
     xdg-shell-v5.json