Client: Use customized version of generated files for xdg-shell-v5

Check in qtwaylandscanner and wayland-scanner generated files with renamed
symbols to avoid conflicts with xdg-shell stable.

When this was done on the compositor side, we thought we didn't have to do it
for the client side because the conflicting symbols are used in separate
plugins. Turns out this breaks static builds, though.

Task-number: QTBUG-69896
Change-Id: I461df8e136b741063eafe13e858734a3aafdf020
Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>

13 files changed, 1868 insertions, 23 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/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..b893b36b2 100644
--- a/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp
+++ b/src/plugins/shellintegration/xdg-shell-v5/qwaylandxdgshellv5.cpp
@@ -52,15 +52,15 @@ QT_BEGIN_NAMESPACE
 
 namespace QtWaylandClient {
 
-QWaylandXdgShellV5::QWaylandXdgShellV5(struct ::xdg_shell *shell)
-    : QtWayland::xdg_shell(shell)
+QWaylandXdgShellV5::QWaylandXdgShellV5(struct ::xdg_shell_v5 *shell)
+    : QtWayland::xdg_shell_v5(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..5e3badeed 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,10 @@ 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 ::xdg_shell_v5 *shell);
     QWaylandXdgShellV5(struct ::wl_registry *registry, uint32_t id);
     ~QWaylandXdgShellV5() override;
 
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