Use QtPlatformHeaders to set platform specific functionality

This involves exposing a new function in the QPlatformNativeInterface
which gets a public function for QGuiApplication

Proof of concept is done through implementing _NET_WM_WINDOW_TYPE
setters for xcb

Change-Id: Ic9544e775fb71cc9b30273595ec41b1cdb1c9d64
Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>

15 files changed, 422 insertions, 1 deletions

diff --git a/src/gui/kernel/qguiapplication.cpp b/src/gui/kernel/qguiapplication.cpp
index 827bf0164b..2d5f717222 100644
--- a/src/gui/kernel/qguiapplication.cpp
+++ b/src/gui/kernel/qguiapplication.cpp
@@ -1413,6 +1413,20 @@ QPlatformNativeInterface *QGuiApplication::platformNativeInterface()
 }
 
 /*!
+    Returns a function pointer from the platformplugin matching \a function
+*/
+QFunctionPointer QGuiApplication::platformFunction(const QByteArray &function)
+{
+    QPlatformIntegration *pi = QGuiApplicationPrivate::platformIntegration();
+    if (!pi) {
+        qWarning() << "QGuiApplication::platformFunction(): Must construct a QGuiApplication before accessing a platform function";
+        return Q_NULLPTR;
+    }
+
+    return pi->nativeInterface() ? pi->nativeInterface()->platformFunction(function) : Q_NULLPTR;
+}
+
+/*!
     Enters the main event loop and waits until exit() is called, and then
     returns the value that was set to exit() (which is 0 if exit() is called
     via quit()).
diff --git a/src/gui/kernel/qguiapplication.h b/src/gui/kernel/qguiapplication.h
index 6d9a4b2376..50aefaadb5 100644
--- a/src/gui/kernel/qguiapplication.h
+++ b/src/gui/kernel/qguiapplication.h
@@ -143,6 +143,8 @@ public:
 
     static QPlatformNativeInterface *platformNativeInterface();
 
+    static QFunctionPointer platformFunction(const QByteArray &function);
+
     static void setQuitOnLastWindowClosed(bool quit);
     static bool quitOnLastWindowClosed();
 
diff --git a/src/gui/kernel/qplatformnativeinterface.cpp b/src/gui/kernel/qplatformnativeinterface.cpp
index 6571a47849..2e5485f1c2 100644
--- a/src/gui/kernel/qplatformnativeinterface.cpp
+++ b/src/gui/kernel/qplatformnativeinterface.cpp
@@ -118,6 +118,12 @@ QPlatformNativeInterface::NativeResourceForBackingStoreFunction QPlatformNativeI
     return 0;
 }
 
+QFunctionPointer QPlatformNativeInterface::platformFunction(const QByteArray &function) const
+{
+    Q_UNUSED(function);
+    return Q_NULLPTR;
+}
+
 /*!
     Contains generic window properties that the platform may utilize.
 */
diff --git a/src/gui/kernel/qplatformnativeinterface.h b/src/gui/kernel/qplatformnativeinterface.h
index eaa24a9e55..58d13c4320 100644
--- a/src/gui/kernel/qplatformnativeinterface.h
+++ b/src/gui/kernel/qplatformnativeinterface.h
@@ -85,6 +85,8 @@ public:
     virtual NativeResourceForWindowFunction nativeResourceFunctionForWindow(const QByteArray &resource);
     virtual NativeResourceForBackingStoreFunction nativeResourceFunctionForBackingStore(const QByteArray &resource);
 
+    virtual QFunctionPointer platformFunction(const QByteArray &function) const;
+
     virtual QVariantMap windowProperties(QPlatformWindow *window) const;
     virtual QVariant windowProperty(QPlatformWindow *window, const QString &name) const;
     virtual QVariant windowProperty(QPlatformWindow *window, const QString &name, const QVariant &defaultValue) const;
diff --git a/src/platformheaders/doc/qtplatformheaders.qdocconf b/src/platformheaders/doc/qtplatformheaders.qdocconf
index dfef69f892..65fe660b40 100644
--- a/src/platformheaders/doc/qtplatformheaders.qdocconf
+++ b/src/platformheaders/doc/qtplatformheaders.qdocconf
@@ -12,7 +12,9 @@ project = QtPlatformHeaders
 
 headerdirs  += ..
 sourcedirs  += ..
-exampledirs += ..
+exampledirs += .. \
+               snippets
+
 imagedirs   += images
 
 depends += qtdoc qtcore qtgui qtwidgets
diff --git a/src/platformheaders/doc/snippets/qxcbwindowfunctions/main.cpp b/src/platformheaders/doc/snippets/qxcbwindowfunctions/main.cpp
new file mode 100644
index 0000000000..d4cb965bda
--- /dev/null
+++ b/src/platformheaders/doc/snippets/qxcbwindowfunctions/main.cpp
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtWidgets>
+#include <QtPlatformHeaders/qxcbwindowfunctions.h>
+
+//! [0]
+int main(int argc, char **argv)
+{
+    QApplication app(argc, argv);
+
+    QPushButton topLevelWidget("Hello World!");
+    topLevelWidget.winId(); //have to create the QWindow
+
+    QWindow *tlwWindow = topLevelWidget.windowHandle();
+
+    QXcbWindowFunctions::setWmWindowType(tlwWindow, QXcbWindowFunctions::Dock);
+
+    topLevelWidget.show();
+
+    return app.exec();
+}
+//! [0]
+
diff --git a/src/platformheaders/doc/src/qtplatformheaders.qdoc b/src/platformheaders/doc/src/qtplatformheaders.qdoc
index 4ed740d296..74df288d3d 100644
--- a/src/platformheaders/doc/src/qtplatformheaders.qdoc
+++ b/src/platformheaders/doc/src/qtplatformheaders.qdoc
@@ -61,8 +61,22 @@
     platforms a different class will be used. These classes are all placed in
     the Qt Platform Headers module.
 
+    Platform headers can be used in conjunction with
+    QGuiApplication::platformFunction() to give a type safe interface to
+    platform specific functionality. It is possible for headers defined in
+    QtPlatformHeaders to define typedefs for functions that can be returned by
+    a platform plugin from QGuiApplication::platformFunction(). Headers in
+    QtPlatformHeaders can also implement wrapper functions for the function
+    pointer, giving a static function that can be called from any context after
+    the platform integration has been created. An implementation of this
+    pattern is QXcbWindowFunctions::setWmWindowType().  This function retrieves
+    a function pointer from QGuiApplication::platformFunction, and executes
+    that function if the requested function was returned.
+
     \note Similar to the other QPA APIs, there are no binary compatibility
     guarantees for these classes, meaning that an application using these
     classes is only guaranteed to work with the Qt version it was developed
     against. Unlike QPA however, source compatibility is guaranteed.
+
+    \sa QXcbWindowFunctions
  */
diff --git a/src/platformheaders/platformheaders.pro b/src/platformheaders/platformheaders.pro
index daf63e7f6c..f99afc4998 100644
--- a/src/platformheaders/platformheaders.pro
+++ b/src/platformheaders/platformheaders.pro
@@ -4,6 +4,7 @@ VERSION = $$MODULE_VERSION
 MODULE_INCNAME = QtPlatformHeaders
 
 include(nativecontexts/nativecontexts.pri)
+include(xcbfunctions/xcbfunctions.pri)
 
 QMAKE_DOCS = $$PWD/doc/qtplatformheaders.qdocconf
 
diff --git a/src/platformheaders/xcbfunctions/qxcbwindowfunctions.h b/src/platformheaders/xcbfunctions/qxcbwindowfunctions.h
new file mode 100644
index 0000000000..48fc0c13b6
--- /dev/null
+++ b/src/platformheaders/xcbfunctions/qxcbwindowfunctions.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXCBWINDOWFUNCTIONS_H
+#define QXCBWINDOWFUNCTIONS_H
+
+#include <QtCore/QByteArray>
+#include <QtGui/QGuiApplication>
+
+QT_BEGIN_NAMESPACE
+
+class QWindow;
+
+class QXcbWindowFunctions {
+public:
+    enum WmWindowType {
+        Normal       = 0x000001,
+        Desktop      = 0x000002,
+        Dock         = 0x000004,
+        Toolbar      = 0x000008,
+        Menu         = 0x000010,
+        Utility      = 0x000020,
+        Splash       = 0x000040,
+        Dialog       = 0x000080,
+        DropDownMenu = 0x000100,
+        PopupMenu    = 0x000200,
+        Tooltip      = 0x000400,
+        Notification = 0x000800,
+        Combo        = 0x001000,
+        Dnd          = 0x002000,
+        KdeOverride  = 0x004000
+    };
+
+    Q_DECLARE_FLAGS(WmWindowTypes, WmWindowType)
+
+    typedef void (*SetWmWindowType)(QWindow *window, QXcbWindowFunctions::WmWindowTypes windowType);
+    static const QByteArray setWmWindowTypeIdentifier() { return QByteArrayLiteral("XcbSetWmWindowType"); }
+
+    static void setWmWindowType(QWindow *window, WmWindowType type)
+    {
+        SetWmWindowType func = reinterpret_cast<SetWmWindowType>(QGuiApplication::platformFunction(setWmWindowTypeIdentifier()));
+        if (func)
+            func(window, type);
+    }
+};
+
+
+QT_END_NAMESPACE
+
+#endif // QXCBWINDOWFUNCTIONS_H
diff --git a/src/platformheaders/xcbfunctions/qxcbwindowfunctions.qdoc b/src/platformheaders/xcbfunctions/qxcbwindowfunctions.qdoc
new file mode 100644
index 0000000000..76af207b3f
--- /dev/null
+++ b/src/platformheaders/xcbfunctions/qxcbwindowfunctions.qdoc
@@ -0,0 +1,79 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file.  Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: http://www.gnu.org/copyleft/fdl.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class QXcbWindowFunctions
+    \inmodule QtPlatformHeaders
+
+    \brief The QXcbWindowFunctions class is an inline class containing
+    miscellaneous functionality for xcb window specific functionality.
+
+    A commen usage pattern is as follows:
+    \snippet qxcbwindowfunctions/main.cpp 0
+*/
+
+/*!
+    \enum QXcbWindowFunctions::WmWindowType
+
+    This enum represents the supported WM_WINDOW_TYPE atoms.
+
+    \value Normal
+    \value Desktop
+    \value Dock
+    \value Toolbar
+    \value Menu
+    \value Utility
+    \value Splash
+    \value Dialog
+    \value DropDownMenu
+    \value PopupMenu
+    \value Tooltip
+    \value Notification
+    \value Combo
+    \value Dnd
+    \value KdeOverride
+*/
+
+/*!
+    \typedef QXcbWindowFunctions::SetWmWindowType
+
+    This is the typedef for the function returned by QGuiApplication::platformFunction when passed setWmWindowTypeIdentifier.
+*/
+
+/*!
+    \fn QByteArray QXcbWindowFunctions::setWmWindowTypeIdentifier()
+
+    This function returnes the bytearray that can be used to query
+    QGuiApplication::platformFunction to retrieve the SetWmWindowType function.
+*/
+
+/*!
+    \fn void QXcbWindowFunctions::setWmWindowType(QWindow *window, WmWindowType type)
+
+    This is a convenience function that can be used directly instead of resolving the function pointer.
+    \a window and \a type will be relayed to the function retrieved by QGuiApplication
+*/
diff --git a/src/platformheaders/xcbfunctions/xcbfunctions.pri b/src/platformheaders/xcbfunctions/xcbfunctions.pri
new file mode 100644
index 0000000000..8844913cd1
--- /dev/null
+++ b/src/platformheaders/xcbfunctions/xcbfunctions.pri
@@ -0,0 +1 @@
+HEADERS += $$PWD/qxcbwindowfunctions.h
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
index 37936a9c72..625a804c0c 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
@@ -60,6 +60,8 @@
 #include "qglxintegration.h"
 #endif
 
+#include <QtPlatformHeaders/qxcbwindowfunctions.h>
+
 #ifdef XCB_USE_XLIB
 #  include <X11/Xlib.h>
 #else
@@ -243,6 +245,14 @@ QPlatformNativeInterface::NativeResourceForScreenFunction QXcbNativeInterface::n
     return 0;
 }
 
+QFunctionPointer QXcbNativeInterface::platformFunction(const QByteArray &function) const
+{
+    if (function == QXcbWindowFunctions::setWmWindowTypeIdentifier()) {
+        return QFunctionPointer(QXcbWindow::setWmWindowTypeStatic);
+    }
+    return Q_NULLPTR;
+}
+
 void *QXcbNativeInterface::appTime(const QXcbScreen *screen)
 {
     return reinterpret_cast<void *>(quintptr(screen->connection()->time()));
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.h b/src/plugins/platforms/xcb/qxcbnativeinterface.h
index cf26aff011..f860e0d267 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.h
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.h
@@ -85,6 +85,8 @@ public:
     NativeResourceForContextFunction nativeResourceFunctionForContext(const QByteArray &resource) Q_DECL_OVERRIDE;
     NativeResourceForScreenFunction nativeResourceFunctionForScreen(const QByteArray &resource) Q_DECL_OVERRIDE;
 
+    QFunctionPointer platformFunction(const QByteArray &function) const Q_DECL_OVERRIDE;
+
     inline const QByteArray &genericEventFilterType() const { return m_genericEventFilterType; }
 
     void *displayForWindow(QWindow *window);
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index 3645b6469a..e4ffda21ea 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -183,6 +183,8 @@ static inline bool positionIncludesFrame(QWindow *w)
     return qt_window_private(w)->positionPolicy == QWindowPrivate::WindowFrameInclusive;
 }
 
+static const char *wm_window_type_property_id = "_q_xcb_wm_window_type";
+
 QXcbWindow::QXcbWindow(QWindow *window)
     : QPlatformWindow(window)
     , m_window(0)
@@ -666,6 +668,9 @@ void QXcbWindow::show()
         updateNetWmStateBeforeMap();
     }
 
+    QXcbWindowFunctions::WmWindowTypes wmWindowTypes(window()->property(wm_window_type_property_id).value<int>());
+    setWmWindowType(wmWindowTypes);
+
     if (connection()->time() != XCB_TIME_CURRENT_TIME)
         updateNetWmUserTime(connection()->time());
 
@@ -1502,6 +1507,133 @@ QXcbEGLSurface *QXcbWindow::eglSurface() const
 }
 #endif
 
+void QXcbWindow::setWmWindowTypeStatic(QWindow *window, QXcbWindowFunctions::WmWindowTypes windowTypes)
+{
+    if (window->handle())
+        static_cast<QXcbWindow *>(window->handle())->setWmWindowType(windowTypes);
+    else
+        window->setProperty(wm_window_type_property_id, QVariant::fromValue(static_cast<int>(windowTypes)));
+}
+
+QXcbWindowFunctions::WmWindowTypes QXcbWindow::wmWindowTypes() const
+{
+    QXcbWindowFunctions::WmWindowTypes result(0);
+
+    xcb_get_property_cookie_t get_cookie =
+        xcb_get_property_unchecked(xcb_connection(), 0, m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE),
+                         XCB_ATOM_ATOM, 0, 1024);
+
+    xcb_get_property_reply_t *reply =
+        xcb_get_property_reply(xcb_connection(), get_cookie, NULL);
+
+    if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
+        const xcb_atom_t *types = static_cast<const xcb_atom_t *>(xcb_get_property_value(reply));
+        const xcb_atom_t *types_end = types + reply->length;
+        for (; types != types_end; types++) {
+            QXcbAtom::Atom type = connection()->qatom(*types);
+            switch (type) {
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL:
+                result |= QXcbWindowFunctions::Normal;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_DESKTOP:
+                result |= QXcbWindowFunctions::Desktop;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_DOCK:
+                qDebug() << "IS DOCK";
+                result |= QXcbWindowFunctions::Dock;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLBAR:
+                result |= QXcbWindowFunctions::Toolbar;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_MENU:
+                result |= QXcbWindowFunctions::Menu;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY:
+                result |= QXcbWindowFunctions::Utility;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH:
+                result |= QXcbWindowFunctions::Splash;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG:
+                result |= QXcbWindowFunctions::Dialog;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_DROPDOWN_MENU:
+                result |= QXcbWindowFunctions::DropDownMenu;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_POPUP_MENU:
+                result |= QXcbWindowFunctions::PopupMenu;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP:
+                result |= QXcbWindowFunctions::Tooltip;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_NOTIFICATION:
+                result |= QXcbWindowFunctions::Notification;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_COMBO:
+                result |= QXcbWindowFunctions::Combo;
+                break;
+            case QXcbAtom::_NET_WM_WINDOW_TYPE_DND:
+                result |= QXcbWindowFunctions::Dnd;
+                break;
+            case QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE:
+                result |= QXcbWindowFunctions::KdeOverride;
+                break;
+            default:
+                break;
+            }
+        }
+        free(reply);
+    }
+    return result;
+}
+
+void QXcbWindow::setWmWindowType(QXcbWindowFunctions::WmWindowTypes types)
+{
+    QVector<xcb_atom_t> atoms;
+
+    if (types & QXcbWindowFunctions::Normal)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NORMAL));
+    if (types & QXcbWindowFunctions::Desktop)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DESKTOP));
+    if (types & QXcbWindowFunctions::Dock) {
+        qDebug() << "setting to be dock";
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DOCK));
+    }
+    if (types & QXcbWindowFunctions::Toolbar)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLBAR));
+    if (types & QXcbWindowFunctions::Menu)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_MENU));
+    if (types & QXcbWindowFunctions::Utility)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_UTILITY));
+    if (types & QXcbWindowFunctions::Splash)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_SPLASH));
+    if (types & QXcbWindowFunctions::Dialog)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DIALOG));
+    if (types & QXcbWindowFunctions::DropDownMenu)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DROPDOWN_MENU));
+    if (types & QXcbWindowFunctions::PopupMenu)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_POPUP_MENU));
+    if (types & QXcbWindowFunctions::Tooltip)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_TOOLTIP));
+    if (types & QXcbWindowFunctions::Notification)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_NOTIFICATION));
+    if (types & QXcbWindowFunctions::Combo)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_COMBO));
+    if (types & QXcbWindowFunctions::Dnd)
+        atoms.append(atom(QXcbAtom::_NET_WM_WINDOW_TYPE_DND));
+    if (types & QXcbWindowFunctions::KdeOverride)
+        atoms.append(atom(QXcbAtom::_KDE_NET_WM_WINDOW_TYPE_OVERRIDE));
+
+    if (atoms.isEmpty()) {
+        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_WINDOW_TYPE)));
+    } else {
+        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                                       atom(QXcbAtom::_NET_WM_WINDOW_TYPE), XCB_ATOM_ATOM, 32,
+                                       atoms.count(), atoms.constData()));
+    }
+    xcb_flush(xcb_connection());
+}
+
 class ExposeCompressor
 {
 public:
diff --git a/src/plugins/platforms/xcb/qxcbwindow.h b/src/plugins/platforms/xcb/qxcbwindow.h
index 12d17023fb..268a2aeaa5 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.h
+++ b/src/plugins/platforms/xcb/qxcbwindow.h
@@ -51,6 +51,8 @@
 
 #include "qxcbobject.h"
 
+#include <QtPlatformHeaders/qxcbwindowfunctions.h>
+
 QT_BEGIN_NAMESPACE
 
 class QXcbScreen;
@@ -151,6 +153,11 @@ public:
     QXcbEGLSurface *eglSurface() const;
 #endif
 
+    static void setWmWindowTypeStatic(QWindow *window, QXcbWindowFunctions::WmWindowTypes windowTypes);
+
+    QXcbWindowFunctions::WmWindowTypes wmWindowTypes() const;
+    void setWmWindowType(QXcbWindowFunctions::WmWindowTypes types);
+
 private:
     void changeNetWmState(bool set, xcb_atom_t one, xcb_atom_t two = 0);
     NetWmStates netWmStates();