18 files changed, 651 insertions, 212 deletions
diff --git a/src/plugins/platforms/xcb/qdri2context.cpp b/src/plugins/platforms/xcb/qdri2context.cpp
index 8bcdacb92b..8eef1b6111 100644
--- a/src/plugins/platforms/xcb/qdri2context.cpp
+++ b/src/plugins/platforms/xcb/qdri2context.cpp
@@ -45,7 +45,7 @@
 #include "qxcbconnection.h"
 
 #include <QtCore/QDebug>
-#include <QtGui/QWidget>
+#include <QtWidgets/QWidget>
 
 #include <xcb/dri2.h>
 #include <xcb/xfixes.h>
@@ -146,7 +146,6 @@ QDri2Context::~QDri2Context()
 
 void QDri2Context::makeCurrent()
 {
-    QPlatformGLContext::makeCurrent();
     Q_D(QDri2Context);
 
     eglMakeCurrent(EGL_DISPLAY_FROM_XCB(d->qXcbWindow),EGL_NO_SURFACE,EGL_NO_SURFACE,d->eglContext);
@@ -156,7 +155,6 @@ void QDri2Context::makeCurrent()
 
 void QDri2Context::doneCurrent()
 {
-    QPlatformGLContext::doneCurrent();
     Q_D(QDri2Context);
     eglMakeCurrent(EGL_DISPLAY_FROM_XCB(d->qXcbWindow),EGL_NO_SURFACE,EGL_NO_SURFACE,EGL_NO_CONTEXT);
 }
diff --git a/src/plugins/platforms/xcb/qglxintegration.cpp b/src/plugins/platforms/xcb/qglxintegration.cpp
index 8e04cbcb71..24d5d69ac7 100644
--- a/src/plugins/platforms/xcb/qglxintegration.cpp
+++ b/src/plugins/platforms/xcb/qglxintegration.cpp
@@ -50,6 +50,8 @@
 #include <X11/Xutil.h>
 #include <GL/glx.h>
 
+#include <QtGui/QWindowContext>
+
 #include "qglxintegration.h"
 #include "qglxconvenience.h"
 
@@ -57,18 +59,17 @@
 #include <dlfcn.h>
 #endif
 
-QGLXContext::QGLXContext(Window window, QXcbScreen *screen, const QPlatformWindowFormat &format)
+QGLXContext::QGLXContext(Window window, QXcbScreen *screen, const QWindowFormat &format)
     : QPlatformGLContext()
     , m_screen(screen)
     , m_drawable((Drawable)window)
     , m_context(0)
 {
     Q_XCB_NOOP(m_screen->connection());
-    const QPlatformGLContext *sharePlatformContext;
-    sharePlatformContext = format.sharedGLContext();
+    const QWindowContext *shareContext = format.sharedContext();
     GLXContext shareGlxContext = 0;
-    if (sharePlatformContext)
-        shareGlxContext = static_cast<const QGLXContext*>(sharePlatformContext)->glxContext();
+    if (shareContext)
+        shareGlxContext = static_cast<const QGLXContext*>(shareContext->handle())->glxContext();
 
     GLXFBConfig config = qglx_findConfig(DISPLAY_FROM_XCB(screen),screen->screenNumber(),format);
     m_context = glXCreateNewContext(DISPLAY_FROM_XCB(screen), config, GLX_RGBA_TYPE, shareGlxContext, TRUE);
@@ -93,7 +94,6 @@ QGLXContext::~QGLXContext()
 void QGLXContext::makeCurrent()
 {
     Q_XCB_NOOP(m_screen->connection());
-    QPlatformGLContext::makeCurrent();
     glXMakeCurrent(DISPLAY_FROM_XCB(m_screen), m_drawable, m_context);
     Q_XCB_NOOP(m_screen->connection());
 }
@@ -101,7 +101,6 @@ void QGLXContext::makeCurrent()
 void QGLXContext::doneCurrent()
 {
     Q_XCB_NOOP(m_screen->connection());
-    QPlatformGLContext::doneCurrent();
     glXMakeCurrent(DISPLAY_FROM_XCB(m_screen), 0, 0);
     Q_XCB_NOOP(m_screen->connection());
 }
@@ -147,7 +146,7 @@ void* QGLXContext::getProcAddress(const QString& procName)
     return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName.toLatin1().data()));
 }
 
-QPlatformWindowFormat QGLXContext::platformWindowFormat() const
+QWindowFormat QGLXContext::windowFormat() const
 {
     return m_windowFormat;
 }
diff --git a/src/plugins/platforms/xcb/qglxintegration.h b/src/plugins/platforms/xcb/qglxintegration.h
index 84de7b7143..1760521d47 100644
--- a/src/plugins/platforms/xcb/qglxintegration.h
+++ b/src/plugins/platforms/xcb/qglxintegration.h
@@ -45,7 +45,7 @@
 #include "qxcbwindow.h"
 
 #include <QtGui/QPlatformGLContext>
-#include <QtGui/QPlatformWindowFormat>
+#include <QtGui/QWindowFormat>
 
 #include <QtCore/QMutex>
 
@@ -54,7 +54,7 @@
 class QGLXContext : public QPlatformGLContext
 {
 public:
-    QGLXContext(Window window, QXcbScreen *xd, const QPlatformWindowFormat &format);
+    QGLXContext(Window window, QXcbScreen *xd, const QWindowFormat &format);
     ~QGLXContext();
 
     virtual void makeCurrent();
@@ -64,13 +64,13 @@ public:
 
     GLXContext glxContext() const { return m_context; }
 
-    QPlatformWindowFormat platformWindowFormat() const;
+    QWindowFormat windowFormat() const;
 
 private:
     QXcbScreen *m_screen;
     Drawable m_drawable;
     GLXContext m_context;
-    QPlatformWindowFormat m_windowFormat;
+    QWindowFormat m_windowFormat;
 
     QGLXContext (QXcbScreen *screen, Drawable drawable, GLXContext context);
 };
diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index 80a1624380..da6e69eb36 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -46,7 +46,7 @@
 
 #include <QtAlgorithms>
 #include <QSocketNotifier>
-#include <QtGui/private/qapplication_p.h>
+#include <QtGui/private/qguiapplication_p.h>
 #include <QAbstractEventDispatcher>
 
 #include <QtCore/QDebug>
@@ -143,22 +143,26 @@ QXcbConnection::~QXcbConnection()
     delete m_keyboard;
 }
 
-QXcbWindow *platformWindowFromId(xcb_window_t id)
+void QXcbConnection::addWindow(xcb_window_t id, QXcbWindow *window)
 {
-    QWidget *widget = QWidget::find(id);
-    if (widget)
-        return static_cast<QXcbWindow *>(widget->platformWindow());
-    return 0;
+    m_mapper.insert(id, window);
 }
 
-#define HANDLE_PLATFORM_WINDOW_EVENT(event_t, window, handler) \
+void QXcbConnection::removeWindow(xcb_window_t id)
+{
+    m_mapper.remove(id);
+}
+
+QXcbWindow *QXcbConnection::platformWindowFromId(xcb_window_t id)
+{
+    return m_mapper.value(id, 0);
+}
+
+#define HANDLE_PLATFORM_WINDOW_EVENT(event_t, windowMember, handler) \
 { \
     event_t *e = (event_t *)event; \
-    if (QXcbWindow *platformWindow = platformWindowFromId(e->window)) { \
-        QObjectPrivate *d = QObjectPrivate::get(platformWindow->widget()); \
-        if (!d->wasDeleted) \
-            platformWindow->handler(e); \
-    } \
+    if (QXcbWindow *platformWindow = platformWindowFromId(e->windowMember)) \
+        platformWindow->handler(e); \
 } \
 break;
 
@@ -166,7 +170,7 @@ break;
 { \
     event_t *e = (event_t *)event; \
     if (QXcbWindow *platformWindow = platformWindowFromId(e->event)) \
-        m_keyboard->handler(platformWindow->widget(), e); \
+        m_keyboard->handler(platformWindow->window(), e); \
 } \
 break;
 
diff --git a/src/plugins/platforms/xcb/qxcbconnection.h b/src/plugins/platforms/xcb/qxcbconnection.h
index 01bc719546..23c704f6de 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@@ -44,6 +44,7 @@
 
 #include <xcb/xcb.h>
 
+#include <QHash>
 #include <QList>
 #include <QObject>
 #include <QVector>
@@ -51,6 +52,9 @@
 #define Q_XCB_DEBUG
 
 class QXcbScreen;
+class QXcbWindow;
+
+typedef QHash<xcb_window_t, QXcbWindow *> WindowMapper;
 
 namespace QXcbAtom {
     enum Atom {
@@ -255,6 +259,9 @@ public:
     void sync();
     void handleXcbError(xcb_generic_error_t *error);
 
+    void addWindow(xcb_window_t id, QXcbWindow *window);
+    void removeWindow(xcb_window_t id);
+
 private slots:
     void processXcbEvents();
 
@@ -264,6 +271,7 @@ private:
 #ifdef XCB_USE_DRI2
     void initializeDri2();
 #endif
+    QXcbWindow *platformWindowFromId(xcb_window_t id);
 
     xcb_connection_t *m_connection;
     const xcb_setup_t *m_setup;
@@ -303,6 +311,8 @@ private:
     template <typename cookie_t>
     friend cookie_t q_xcb_call_template(const cookie_t &cookie, QXcbConnection *connection, const char *file, int line);
 #endif
+
+    WindowMapper m_mapper;
 };
 
 #define DISPLAY_FROM_XCB(object) ((Display *)(object->connection()->xlib_display()))
diff --git a/src/plugins/platforms/xcb/qxcbintegration.cpp b/src/plugins/platforms/xcb/qxcbintegration.cpp
index 12b63f36ea..8c2ed03b60 100644
--- a/src/plugins/platforms/xcb/qxcbintegration.cpp
+++ b/src/plugins/platforms/xcb/qxcbintegration.cpp
@@ -87,16 +87,15 @@ QPixmapData *QXcbIntegration::createPixmapData(QPixmapData::PixelType type) cons
     return new QRasterPixmapData(type);
 }
 
-QPlatformWindow *QXcbIntegration::createPlatformWindow(QWidget *widget, WId winId) const
+QPlatformWindow *QXcbIntegration::createPlatformWindow(QWindow *window) const
 {
-    Q_UNUSED(winId);
-    return new QXcbWindow(widget);
+    return new QXcbWindow(window);
 }
 
-QWindowSurface *QXcbIntegration::createWindowSurface(QWidget *widget, WId winId) const
+QWindowSurface *QXcbIntegration::createWindowSurface(QWindow *window, WId winId) const
 {
     Q_UNUSED(winId);
-    return new QXcbWindowSurface(widget);
+    return new QXcbWindowSurface(window);
 }
 
 QList<QPlatformScreen *> QXcbIntegration::screens() const
diff --git a/src/plugins/platforms/xcb/qxcbintegration.h b/src/plugins/platforms/xcb/qxcbintegration.h
index cd68919b54..5ab929828d 100644
--- a/src/plugins/platforms/xcb/qxcbintegration.h
+++ b/src/plugins/platforms/xcb/qxcbintegration.h
@@ -57,8 +57,8 @@ public:
 
     bool hasCapability(Capability cap) const;
     QPixmapData *createPixmapData(QPixmapData::PixelType type) const;
-    QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId) const;
-    QWindowSurface *createWindowSurface(QWidget *widget, WId winId) const;
+    QPlatformWindow *createPlatformWindow(QWindow *window) const;
+    QWindowSurface *createWindowSurface(QWindow *window, WId winId) const;
 
     QList<QPlatformScreen *> screens() const;
     void moveToScreen(QWidget *window, int screen);
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.cpp b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
index 6bbc3c18ca..80f937769f 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
@@ -913,7 +913,7 @@ QXcbKeyboard::~QXcbKeyboard()
 
 // #define XCB_KEYBOARD_DEBUG
 
-void QXcbKeyboard::handleKeyEvent(QWidget *widget, QEvent::Type type, xcb_keycode_t code, quint16 state, xcb_timestamp_t time)
+void QXcbKeyboard::handleKeyEvent(QWindow *window, QEvent::Type type, xcb_keycode_t code, quint16 state, xcb_timestamp_t time)
 {
     int col = state & XCB_MOD_MASK_SHIFT ? 1 : 0;
 
@@ -954,17 +954,17 @@ void QXcbKeyboard::handleKeyEvent(QWidget *widget, QEvent::Type type, xcb_keycod
 
     QString string = translateKeySym(sym, state, qtcode, modifiers, chars, count);
 
-    QWindowSystemInterface::handleExtendedKeyEvent(widget, time, type, qtcode, modifiers, code, 0, state, string.left(count));
+    QWindowSystemInterface::handleExtendedKeyEvent(window, time, type, qtcode, modifiers, code, 0, state, string.left(count));
 }
 
-void QXcbKeyboard::handleKeyPressEvent(QWidget *widget, const xcb_key_press_event_t *event)
+void QXcbKeyboard::handleKeyPressEvent(QWindow *window, const xcb_key_press_event_t *event)
 {
-    handleKeyEvent(widget, QEvent::KeyPress, event->detail, event->state, event->time);
+    handleKeyEvent(window, QEvent::KeyPress, event->detail, event->state, event->time);
 }
 
-void QXcbKeyboard::handleKeyReleaseEvent(QWidget *widget, const xcb_key_release_event_t *event)
+void QXcbKeyboard::handleKeyReleaseEvent(QWindow *window, const xcb_key_release_event_t *event)
 {
-    handleKeyEvent(widget, QEvent::KeyRelease, event->detail, event->state, event->time);
+    handleKeyEvent(window, QEvent::KeyRelease, event->detail, event->state, event->time);
 }
 
 void QXcbKeyboard::handleMappingNotifyEvent(const xcb_mapping_notify_event_t *event)
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.h b/src/plugins/platforms/xcb/qxcbkeyboard.h
index 095c3e4efb..98e8c90d68 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.h
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.h
@@ -48,21 +48,23 @@
 
 #include <QEvent>
 
+class QWindow;
+
 class QXcbKeyboard : public QXcbObject
 {
 public:
     QXcbKeyboard(QXcbConnection *connection);
     ~QXcbKeyboard();
 
-    void handleKeyPressEvent(QWidget *widget, const xcb_key_press_event_t *event);
-    void handleKeyReleaseEvent(QWidget *widget, const xcb_key_release_event_t *event);
+    void handleKeyPressEvent(QWindow *window, const xcb_key_press_event_t *event);
+    void handleKeyReleaseEvent(QWindow *window, const xcb_key_release_event_t *event);
 
     void handleMappingNotifyEvent(const xcb_mapping_notify_event_t *event);
 
     Qt::KeyboardModifiers translateModifiers(int s);
 
 private:
-    void handleKeyEvent(QWidget *widget, QEvent::Type type, xcb_keycode_t code, quint16 state, xcb_timestamp_t time);
+    void handleKeyEvent(QWindow *window, QEvent::Type type, xcb_keycode_t code, quint16 state, xcb_timestamp_t time);
 
     int translateKeySym(uint key) const;
     QString translateKeySym(xcb_keysym_t keysym, uint xmodifiers,
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
index 6423f1b798..43f93d07bc 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
@@ -43,11 +43,13 @@
 
 #include "qxcbscreen.h"
 
-#include <QtGui/private/qapplication_p.h>
+#include <private/qguiapplication_p.h>
 #include <QtCore/QMap>
 
 #include <QtCore/QDebug>
 
+#include <QtGui/qwindowcontext_qpa.h>
+
 #if defined(XCB_USE_EGL)
 #include "../eglconvenience/qeglplatformcontext.h"
 #elif defined (XCB_USE_DRI2)
@@ -71,29 +73,29 @@ public:
 
 Q_GLOBAL_STATIC(QXcbResourceMap, qXcbResourceMap)
 
-void *QXcbNativeInterface::nativeResourceForWidget(const QByteArray &resourceString, QWidget *widget)
+void *QXcbNativeInterface::nativeResourceForWindow(const QByteArray &resourceString, QWindow *window)
 {
     QByteArray lowerCaseResource = resourceString.toLower();
     ResourceType resource = qXcbResourceMap()->value(lowerCaseResource);
     void *result = 0;
     switch(resource) {
     case Display:
-        result = displayForWidget(widget);
+        result = displayForWindow(window);
         break;
     case EglDisplay:
-        result = eglDisplayForWidget(widget);
+        result = eglDisplayForWindow(window);
         break;
     case Connection:
-        result = connectionForWidget(widget);
+        result = connectionForWindow(window);
         break;
     case Screen:
-        result = qPlatformScreenForWidget(widget);
+        result = qPlatformScreenForWindow(window);
         break;
     case GraphicsDevice:
-        result = graphicsDeviceForWidget(widget);
+        result = graphicsDeviceForWindow(window);
         break;
     case EglContext:
-        result = eglContextForWidget(widget);
+        result = eglContextForWindow(window);
         break;
     default:
         result = 0;
@@ -101,75 +103,70 @@ void *QXcbNativeInterface::nativeResourceForWidget(const QByteArray &resourceStr
     return result;
 }
 
-QXcbScreen *QXcbNativeInterface::qPlatformScreenForWidget(QWidget *widget)
+QXcbScreen *QXcbNativeInterface::qPlatformScreenForWindow(QWindow *window)
 {
     QXcbScreen *screen;
-    if (widget) {
-        screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(widget));
+    if (window) {
+        screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWindow(window));
     }else {
-        screen = static_cast<QXcbScreen *>(QApplicationPrivate::platformIntegration()->screens()[0]);
+        screen = static_cast<QXcbScreen *>(QGuiApplicationPrivate::platformIntegration()->screens()[0]);
     }
     return screen;
 }
 
-void *QXcbNativeInterface::displayForWidget(QWidget *widget)
+void *QXcbNativeInterface::displayForWindow(QWindow *window)
 {
 #if defined(XCB_USE_XLIB)
-    QXcbScreen *screen = qPlatformScreenForWidget(widget);
+    QXcbScreen *screen = qPlatformScreenForWindow(window);
     return screen->connection()->xlib_display();
 #else
-    Q_UNUSED(widget);
+    Q_UNUSED(window);
     return 0;
 #endif
 }
 
-void *QXcbNativeInterface::eglDisplayForWidget(QWidget *widget)
+void *QXcbNativeInterface::eglDisplayForWindow(QWindow *window)
 {
 #if defined(XCB_USE_DRI2) || defined(XCB_USE_EGL)
-    QXcbScreen *screen = qPlatformScreenForWidget(widget);
+    QXcbScreen *screen = qPlatformScreenForWindow(window);
     return screen->connection()->egl_display();
 #else
-    Q_UNUSED(widget)
+    Q_UNUSED(window)
     return 0;
 #endif
 }
 
-void *QXcbNativeInterface::connectionForWidget(QWidget *widget)
+void *QXcbNativeInterface::connectionForWindow(QWindow *window)
 {
-    QXcbScreen *screen = qPlatformScreenForWidget(widget);
+    QXcbScreen *screen = qPlatformScreenForWindow(window);
     return screen->xcb_connection();
 }
 
-void *QXcbNativeInterface::screenForWidget(QWidget *widget)
+void *QXcbNativeInterface::screenForWindow(QWindow *window)
 {
-    QXcbScreen *screen = qPlatformScreenForWidget(widget);
+    QXcbScreen *screen = qPlatformScreenForWindow(window);
     return screen->screen();
 }
 
-void *QXcbNativeInterface::graphicsDeviceForWidget(QWidget *widget)
+void *QXcbNativeInterface::graphicsDeviceForWindow(QWindow *window)
 {
 #if defined(XCB_USE_DRI2)
-    QXcbScreen *screen = qPlatformScreenForWidget(widget);
+    QXcbScreen *screen = qPlatformScreenForWindow(window);
     QByteArray deviceName = screen->connection()->dri2DeviceName();
     return deviceName.data();
 #else
-    Q_UNUSED(widget);
+    Q_UNUSED(window);
     return 0;
 #endif
 
 }
 
-void * QXcbNativeInterface::eglContextForWidget(QWidget *widget)
+void * QXcbNativeInterface::eglContextForWindow(QWindow *window)
 {
-    Q_ASSERT(widget);
-    if (!widget->platformWindow()) {
-        qDebug() << "QPlatformWindow does not exist for widget" << widget
-                 << "cannot return EGLContext";
-        return 0;
-    }
-    QPlatformGLContext *platformContext = widget->platformWindow()->glContext();
+    Q_ASSERT(window);
+    QPlatformGLContext *platformContext = window->glContext()->handle();
     if (!platformContext) {
-        qDebug() << "QPlatformWindow" << widget->platformWindow() << "does not have a glContext"
+        qDebug() << "QWindow" << window << "does not have a glContext"
                  << "cannot return EGLContext";
         return 0;
     }
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.h b/src/plugins/platforms/xcb/qxcbnativeinterface.h
index 3fb0fa5e2d..10e3f6350c 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.h
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.h
@@ -59,17 +59,17 @@ public:
         EglContext
     };
 
-    void *nativeResourceForWidget(const QByteArray &resourceString, QWidget *widget);
+    void *nativeResourceForWindow(const QByteArray &resourceString, QWindow *window);
 
-    void *displayForWidget(QWidget *widget);
-    void *eglDisplayForWidget(QWidget *widget);
-    void *connectionForWidget(QWidget *widget);
-    void *screenForWidget(QWidget *widget);
-    void *graphicsDeviceForWidget(QWidget *widget);
-    void *eglContextForWidget(QWidget *widget);
+    void *displayForWindow(QWindow *window);
+    void *eglDisplayForWindow(QWindow *window);
+    void *connectionForWindow(QWindow *window);
+    void *screenForWindow(QWindow *window);
+    void *graphicsDeviceForWindow(QWindow *window);
+    void *eglContextForWindow(QWindow *window);
 
 private:
-    static QXcbScreen *qPlatformScreenForWidget(QWidget *widget);
+    static QXcbScreen *qPlatformScreenForWindow(QWindow *window);
 };
 
 #endif // QXCBNATIVEINTERFACE_H
diff --git a/src/plugins/platforms/xcb/qxcbscreen.cpp b/src/plugins/platforms/xcb/qxcbscreen.cpp
index 9a4858123b..7aef0275e3 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.cpp
+++ b/src/plugins/platforms/xcb/qxcbscreen.cpp
@@ -102,6 +102,26 @@ QXcbScreen::QXcbScreen(QXcbConnection *connection, xcb_screen_t *screen, int num
     free(reply);
 
     m_syncRequestSupported = m_windowManagerName != QLatin1String("KWin");
+
+    m_clientLeader = xcb_generate_id(xcb_connection());
+    Q_XCB_CALL2(xcb_create_window(xcb_connection(),
+                                  XCB_COPY_FROM_PARENT,
+                                  m_clientLeader,
+                                  m_screen->root,
+                                  0, 0, 1, 1,
+                                  0,
+                                  XCB_WINDOW_CLASS_INPUT_OUTPUT,
+                                  m_screen->root_visual,
+                                  0, 0), connection);
+
+    Q_XCB_CALL2(xcb_change_property(xcb_connection(),
+                                    XCB_PROP_MODE_REPLACE,
+                                    m_clientLeader,
+                                    atom(QXcbAtom::WM_CLIENT_LEADER),
+                                    XCB_ATOM_WINDOW,
+                                    32,
+                                    1,
+                                    &m_clientLeader), connection);
 }
 
 QXcbScreen::~QXcbScreen()
diff --git a/src/plugins/platforms/xcb/qxcbscreen.h b/src/plugins/platforms/xcb/qxcbscreen.h
index a78ee822f4..38ec52de0a 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.h
+++ b/src/plugins/platforms/xcb/qxcbscreen.h
@@ -67,6 +67,8 @@ public:
     xcb_screen_t *screen() const { return m_screen; }
     xcb_window_t root() const { return m_screen->root; }
 
+    xcb_window_t clientLeader() const { return m_clientLeader; }
+
     QString windowManagerName() const { return m_windowManagerName; }
     bool syncRequestSupported() const { return m_syncRequestSupported; }
 
@@ -75,6 +77,7 @@ private:
     int m_number;
     QString m_windowManagerName;
     bool m_syncRequestSupported;
+    xcb_window_t m_clientLeader;
 };
 
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index 0a02c7eff5..1460d7ea81 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -51,7 +51,8 @@
 
 #include <xcb/xcb_icccm.h>
 
-#include <private/qapplication_p.h>
+#include <private/qguiapplication_p.h>
+#include <private/qwindow_p.h>
 #include <private/qwindowsurface_p.h>
 
 #include <QtGui/QWindowSystemInterface>
@@ -72,31 +73,51 @@
 #include "../eglconvenience/qxlibeglintegration.h"
 #endif
 
+//#ifdef NET_WM_STATE_DEBUG
+
 // Returns true if we should set WM_TRANSIENT_FOR on \a w
-static inline bool isTransient(const QWidget *w)
+static inline bool isTransient(const QWindow *w)
 {
-    return ((w->windowType() == Qt::Dialog
-             || w->windowType() == Qt::Sheet
-             || w->windowType() == Qt::Tool
-             || w->windowType() == Qt::SplashScreen
-             || w->windowType() == Qt::ToolTip
-             || w->windowType() == Qt::Drawer
-             || w->windowType() == Qt::Popup)
-            && !w->testAttribute(Qt::WA_X11BypassTransientForHint));
+    return w->windowType() == Qt::Dialog
+           || w->windowType() == Qt::Sheet
+           || w->windowType() == Qt::Tool
+           || w->windowType() == Qt::SplashScreen
+           || w->windowType() == Qt::ToolTip
+           || w->windowType() == Qt::Drawer
+           || w->windowType() == Qt::Popup;
 }
 
-QXcbWindow::QXcbWindow(QWidget *tlw)
-    : QPlatformWindow(tlw)
+QXcbWindow::QXcbWindow(QWindow *window)
+    : QPlatformWindow(window)
+    , m_window(0)
     , m_context(0)
+    , m_syncCounter(0)
 {
-    m_screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(tlw));
+    m_screen = static_cast<QXcbScreen *>(QGuiApplicationPrivate::platformIntegration()->screens().at(0));
 
     setConnection(m_screen->connection());
 
-    const quint32 mask = XCB_CW_BACK_PIXMAP | XCB_CW_EVENT_MASK;
+    create();
+}
+
+void QXcbWindow::create()
+{
+    bool wasCreated = (m_window != 0);
+    destroy();
+
+    m_windowState = Qt::WindowNoState;
+    m_hasReceivedSyncRequest = false;
+
+    Qt::WindowType type = window()->windowType();
+
+    const quint32 mask = XCB_CW_BACK_PIXMAP | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_SAVE_UNDER | XCB_CW_EVENT_MASK;
     const quint32 values[] = {
         // XCB_CW_BACK_PIXMAP
         XCB_NONE,
+        // XCB_CW_OVERRIDE_REDIRECT
+        type == Qt::Popup,
+        // XCB_CW_SAVE_UNDER
+        type == Qt::Popup || type == Qt::Tool || type == Qt::SplashScreen || type == Qt::ToolTip || type == Qt::Drawer,
         // XCB_CW_EVENT_MASK
         XCB_EVENT_MASK_EXPOSURE
         | XCB_EVENT_MASK_STRUCTURE_NOTIFY
@@ -107,20 +128,27 @@ QXcbWindow::QXcbWindow(QWidget *tlw)
         | XCB_EVENT_MASK_BUTTON_MOTION
         | XCB_EVENT_MASK_ENTER_WINDOW
         | XCB_EVENT_MASK_LEAVE_WINDOW
+        | XCB_EVENT_MASK_POINTER_MOTION
         | XCB_EVENT_MASK_PROPERTY_CHANGE
         | XCB_EVENT_MASK_FOCUS_CHANGE
     };
 
+    QRect rect = window()->geometry();
+
+    xcb_window_t xcb_parent_id = m_screen->root();
+    if (parent())
+        xcb_parent_id = static_cast<QXcbWindow *>(parent())->xcb_window();
+
 #if defined(XCB_USE_GLX) || defined(XCB_USE_EGL)
-    if (tlw->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenGL
-        && QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)
-        || tlw->platformWindowFormat().alpha())
+    if ((window()->surfaceType() == QWindow::OpenGLSurface
+        && QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL))
+        || window()->requestedWindowFormat().hasAlpha())
     {
 #if defined(XCB_USE_GLX)
-        XVisualInfo *visualInfo = qglx_findVisualInfo(DISPLAY_FROM_XCB(m_screen),m_screen->screenNumber(), tlw->platformWindowFormat());
+        XVisualInfo *visualInfo = qglx_findVisualInfo(DISPLAY_FROM_XCB(m_screen),m_screen->screenNumber(), window()->requestedWindowFormat());
 #elif defined(XCB_USE_EGL)
         EGLDisplay eglDisplay = connection()->egl_display();
-        EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,tlw->platformWindowFormat(),true);
+        EGLConfig eglConfig = q_configFromQPlatformWindowFormat(eglDisplay,window()->requestedWindowFormat(),true);
         VisualID id = QXlibEglIntegration::getCompatibleVisualId(DISPLAY_FROM_XCB(this), eglDisplay, eglConfig);
 
         XVisualInfo visualInfoTemplate;
@@ -134,17 +162,17 @@ QXcbWindow::QXcbWindow(QWidget *tlw)
         if (visualInfo) {
             m_depth = visualInfo->depth;
             m_format = (m_depth == 32) ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;
-            Colormap cmap = XCreateColormap(DISPLAY_FROM_XCB(this), m_screen->root(), visualInfo->visual, AllocNone);
+            Colormap cmap = XCreateColormap(DISPLAY_FROM_XCB(this), xcb_parent_id, visualInfo->visual, AllocNone);
 
             XSetWindowAttributes a;
             a.background_pixel = WhitePixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber());
             a.border_pixel = BlackPixel(DISPLAY_FROM_XCB(this), m_screen->screenNumber());
             a.colormap = cmap;
-            m_window = XCreateWindow(DISPLAY_FROM_XCB(this), m_screen->root(), tlw->x(), tlw->y(), tlw->width(), tlw->height(),
+            m_window = XCreateWindow(DISPLAY_FROM_XCB(this), xcb_parent_id, rect.x(), rect.y(), rect.width(), rect.height(),
                                       0, visualInfo->depth, InputOutput, visualInfo->visual,
                                       CWBackPixel|CWBorderPixel|CWColormap, &a);
 
-            printf("created GL window: %d\n", m_window);
+            printf("created GL window: %x\n", m_window);
         } else {
             qFatal("no window!");
         }
@@ -158,20 +186,22 @@ QXcbWindow::QXcbWindow(QWidget *tlw)
         Q_XCB_CALL(xcb_create_window(xcb_connection(),
                                      XCB_COPY_FROM_PARENT,            // depth -- same as root
                                      m_window,                        // window id
-                                     m_screen->root(),                // parent window id
-                                     tlw->x(),
-                                     tlw->y(),
-                                     tlw->width(),
-                                     tlw->height(),
+                                     xcb_parent_id,                   // parent window id
+                                     rect.x(),
+                                     rect.y(),
+                                     rect.width(),
+                                     rect.height(),
                                      0,                               // border width
                                      XCB_WINDOW_CLASS_INPUT_OUTPUT,   // window class
                                      m_screen->screen()->root_visual, // visual
                                      0,                               // value mask
                                      0));                             // value list
 
-        printf("created regular window: %d\n", m_window);
+        printf("created regular window: %x\n", m_window);
     }
 
+    connection()->addWindow(m_window, this);
+
     Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));
 
     xcb_atom_t properties[4];
@@ -183,7 +213,7 @@ QXcbWindow::QXcbWindow(QWidget *tlw)
     if (m_screen->syncRequestSupported())
         properties[propertyCount++] = atom(QXcbAtom::_NET_WM_SYNC_REQUEST);
 
-    if (tlw->windowFlags() & Qt::WindowContextHelpButtonHint)
+    if (window()->windowFlags() & Qt::WindowContextHelpButtonHint)
         properties[propertyCount++] = atom(QXcbAtom::_NET_WM_CONTEXT_HELP);
 
     Q_XCB_CALL(xcb_change_property(xcb_connection(),
@@ -211,29 +241,41 @@ QXcbWindow::QXcbWindow(QWidget *tlw)
                                        &m_syncCounter));
     }
 
-    if (isTransient(tlw) && tlw->parentWidget()) {
-        // ICCCM 4.1.2.6
-        QWidget *p = tlw->parentWidget()->window();
-        xcb_window_t parentWindow = p->winId();
-        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
-                                       XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
-                                       1, &parentWindow));
-
-    }
-
     // set the PID to let the WM kill the application if unresponsive
     long pid = getpid();
     Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
                                    atom(QXcbAtom::_NET_WM_PID), XCB_ATOM_CARDINAL, 32,
                                    1, &pid));
+
+    xcb_wm_hints_t hints;
+    memset(&hints, 0, sizeof(hints));
+    xcb_wm_hints_set_normal(&hints);
+
+    xcb_set_wm_hints(xcb_connection(), m_window, &hints);
+
+    xcb_window_t leader = m_screen->clientLeader();
+    Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                                   atom(QXcbAtom::WM_CLIENT_LEADER), XCB_ATOM_WINDOW, 32,
+                                   1, &leader));
+
+    if (wasCreated)
+        setWindowFlags(window()->windowFlags());
 }
 
 QXcbWindow::~QXcbWindow()
 {
+    destroy();
+}
+
+void QXcbWindow::destroy()
+{
     delete m_context;
-    if (m_screen->syncRequestSupported())
+    if (m_syncCounter && m_screen->syncRequestSupported())
         Q_XCB_CALL(xcb_sync_destroy_counter(xcb_connection(), m_syncCounter));
-    Q_XCB_CALL(xcb_destroy_window(xcb_connection(), m_window));
+    if (m_window) {
+        connection()->removeWindow(m_window);
+        Q_XCB_CALL(xcb_destroy_window(xcb_connection(), m_window));
+    }
 }
 
 void QXcbWindow::setGeometry(const QRect &rect)
@@ -248,33 +290,81 @@ void QXcbWindow::setGeometry(const QRect &rect)
 
 void QXcbWindow::setVisible(bool visible)
 {
-    xcb_wm_hints_t hints;
-    if (visible) {
-        if (widget()->isMinimized())
+    if (visible)
+        show();
+    else
+        hide();
+}
+
+void QXcbWindow::show()
+{
+    if (window()->isTopLevel()) {
+        xcb_get_property_cookie_t cookie = xcb_get_wm_hints(xcb_connection(), m_window);
+
+        xcb_generic_error_t *error;
+
+        xcb_wm_hints_t hints;
+        xcb_get_wm_hints_reply(xcb_connection(), cookie, &hints, &error);
+
+        if (error) {
+            connection()->handleXcbError(error);
+            free(error);
+        }
+
+        if (window()->windowState() & Qt::WindowMinimized)
             xcb_wm_hints_set_iconic(&hints);
         else
             xcb_wm_hints_set_normal(&hints);
+
         xcb_set_wm_hints(xcb_connection(), m_window, &hints);
-        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
-        connection()->sync();
-    } else {
-        Q_XCB_CALL(xcb_unmap_window(xcb_connection(), m_window));
-
-        // send synthetic UnmapNotify event according to icccm 4.1.4
-        xcb_unmap_notify_event_t event;
-        event.response_type = XCB_UNMAP_NOTIFY;
-        event.sequence = 0; // does this matter?
-        event.event = m_screen->root();
-        event.window = m_window;
-        event.from_configure = false;
-        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, m_screen->root(),
-                                  XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
 
-        xcb_flush(xcb_connection());
+        // update WM_NORMAL_HINTS
+        propagateSizeHints();
+
+        // update WM_TRANSIENT_FOR
+        if (window()->transientParent() && isTransient(window())) {
+            QXcbWindow *transientXcbParent = static_cast<QXcbWindow *>(window()->transientParent()->handle());
+            if (transientXcbParent) {
+                // ICCCM 4.1.2.6
+                xcb_window_t parentWindow = transientXcbParent->xcb_window();
+
+                // todo: set transient for group (wm_client_leader) if no parent, a la qwidget_x11.cpp
+                Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                                               XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
+                                               1, &parentWindow));
+            }
+        }
+
+        // update _MOTIF_WM_HINTS
+        updateMotifWmHintsBeforeMap();
+
+        // update _NET_WM_STATE
+        updateNetWmStateBeforeMap();
     }
+
+    Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
+    xcb_flush(xcb_connection());
+
+    connection()->sync();
+}
+
+void QXcbWindow::hide()
+{
+    Q_XCB_CALL(xcb_unmap_window(xcb_connection(), m_window));
+
+    // send synthetic UnmapNotify event according to icccm 4.1.4
+    xcb_unmap_notify_event_t event;
+    event.response_type = XCB_UNMAP_NOTIFY;
+    event.event = m_screen->root();
+    event.window = m_window;
+    event.from_configure = false;
+    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, m_screen->root(),
+                              XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+
+    xcb_flush(xcb_connection());
 }
 
-struct QtMWMHints {
+struct QtMotifWmHints {
     quint32 flags, functions, decorations;
     qint32 input_mode;
     quint32 status;
@@ -307,33 +397,142 @@ enum {
     MWM_INPUT_FULL_APPLICATION_MODAL    = 3L
 };
 
+static QtMotifWmHints getMotifWmHints(QXcbConnection *c, xcb_window_t window)
+{
+    QtMotifWmHints hints;
+
+    xcb_get_property_cookie_t get_cookie =
+        xcb_get_property(c->xcb_connection(), 0, window, c->atom(QXcbAtom::_MOTIF_WM_HINTS),
+                         c->atom(QXcbAtom::_MOTIF_WM_HINTS), 0, 20);
+
+    xcb_generic_error_t *error;
+
+    xcb_get_property_reply_t *reply =
+        xcb_get_property_reply(c->xcb_connection(), get_cookie, &error);
+
+    if (reply && reply->format == 32 && reply->type == c->atom(QXcbAtom::_MOTIF_WM_HINTS)) {
+        hints = *((QtMotifWmHints *)xcb_get_property_value(reply));
+    } else if (error) {
+        c->handleXcbError(error);
+        free(error);
+
+        hints.flags = 0L;
+        hints.functions = MWM_FUNC_ALL;
+        hints.decorations = MWM_DECOR_ALL;
+        hints.input_mode = 0L;
+        hints.status = 0L;
+    }
+
+    free(reply);
+
+    return hints;
+}
+
+static void setMotifWmHints(QXcbConnection *c, xcb_window_t window, const QtMotifWmHints &hints)
+{
+    if (hints.flags != 0l) {
+        Q_XCB_CALL2(xcb_change_property(c->xcb_connection(),
+                                       XCB_PROP_MODE_REPLACE,
+                                       window,
+                                       c->atom(QXcbAtom::_MOTIF_WM_HINTS),
+                                       c->atom(QXcbAtom::_MOTIF_WM_HINTS),
+                                       32,
+                                       5,
+                                       &hints), c);
+    } else {
+        Q_XCB_CALL2(xcb_delete_property(c->xcb_connection(), window, c->atom(QXcbAtom::_MOTIF_WM_HINTS)), c);
+    }
+}
+
+void QXcbWindow::printNetWmState(const QVector<xcb_atom_t> &state)
+{
+    printf("_NET_WM_STATE (%d): ", state.size());
+    for (int i = 0; i < state.size(); ++i) {
+#define CHECK_WM_STATE(state_atom) \
+        if (state.at(i) == atom(QXcbAtom::state_atom))\
+            printf(#state_atom " ");
+        CHECK_WM_STATE(_NET_WM_STATE_ABOVE)
+        CHECK_WM_STATE(_NET_WM_STATE_BELOW)
+        CHECK_WM_STATE(_NET_WM_STATE_FULLSCREEN)
+        CHECK_WM_STATE(_NET_WM_STATE_MAXIMIZED_HORZ)
+        CHECK_WM_STATE(_NET_WM_STATE_MAXIMIZED_VERT)
+        CHECK_WM_STATE(_NET_WM_STATE_MODAL)
+        CHECK_WM_STATE(_NET_WM_STATE_STAYS_ON_TOP)
+        CHECK_WM_STATE(_NET_WM_STATE_DEMANDS_ATTENTION)
+#undef CHECK_WM_STATE
+    }
+    printf("\n");
+}
+
+QVector<xcb_atom_t> QXcbWindow::getNetWmState()
+{
+    QVector<xcb_atom_t> result;
+
+    xcb_get_property_cookie_t get_cookie =
+        xcb_get_property(xcb_connection(), 0, m_window, atom(QXcbAtom::_NET_WM_STATE),
+                         XCB_ATOM_ATOM, 0, 1024);
+
+    xcb_generic_error_t *error;
+
+    xcb_get_property_reply_t *reply =
+        xcb_get_property_reply(xcb_connection(), get_cookie, &error);
+
+    if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM) {
+        result.resize(reply->length);
+
+        memcpy(result.data(), xcb_get_property_value(reply), reply->length * sizeof(xcb_atom_t));
+
+#ifdef NET_WM_STATE_DEBUG
+        printf("getting net wm state (%x)\n", m_window);
+        printNetWmState(result);
+#endif
+
+        free(reply);
+    } else if (error) {
+        connection()->handleXcbError(error);
+        free(error);
+    } else {
+#ifdef NET_WM_STATE_DEBUG
+        printf("getting net wm state (%x), empty\n", m_window);
+#endif
+    }
+
+    return result;
+}
+
+void QXcbWindow::setNetWmState(const QVector<xcb_atom_t> &atoms)
+{
+    if (atoms.isEmpty()) {
+        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_NET_WM_STATE)));
+    } else {
+        Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
+                                       atom(QXcbAtom::_NET_WM_STATE), XCB_ATOM_ATOM, 32,
+                                       atoms.count(), atoms.constData()));
+    }
+    xcb_flush(xcb_connection());
+}
+
+
 Qt::WindowFlags QXcbWindow::setWindowFlags(Qt::WindowFlags flags)
 {
     Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
 
-    setNetWmWindowTypes(flags);
-
     if (type == Qt::ToolTip)
         flags |= Qt::WindowStaysOnTopHint | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint;
     if (type == Qt::Popup)
         flags |= Qt::X11BypassWindowManagerHint;
 
-    bool topLevel = (flags & Qt::Window);
-    bool popup = (type == Qt::Popup);
-    bool dialog = (type == Qt::Dialog
-                   || type == Qt::Sheet);
-    bool desktop = (type == Qt::Desktop);
-    bool tool = (type == Qt::Tool || type == Qt::SplashScreen
-                 || type == Qt::ToolTip || type == Qt::Drawer);
+    setNetWmWindowFlags(flags);
+    setMotifWindowFlags(flags);
 
-    Q_UNUSED(topLevel);
-    Q_UNUSED(dialog);
-    Q_UNUSED(desktop);
-    Q_UNUSED(tool);
+    return flags;
+}
 
-    bool tooltip = (type == Qt::ToolTip);
+void QXcbWindow::setMotifWindowFlags(Qt::WindowFlags flags)
+{
+    Qt::WindowType type = static_cast<Qt::WindowType>(int(flags & Qt::WindowType_Mask));
 
-    QtMWMHints mwmhints;
+    QtMotifWmHints mwmhints;
     mwmhints.flags = 0L;
     mwmhints.functions = 0L;
     mwmhints.decorations = 0;
@@ -393,30 +592,88 @@ Qt::WindowFlags QXcbWindow::setWindowFlags(Qt::WindowFlags flags)
         mwmhints.decorations = 0;
     }
 
-    if (mwmhints.flags != 0l) {
-        Q_XCB_CALL(xcb_change_property(xcb_connection(),
-                                       XCB_PROP_MODE_REPLACE,
-                                       m_window,
-                                       atom(QXcbAtom::_MOTIF_WM_HINTS),
-                                       atom(QXcbAtom::_MOTIF_WM_HINTS),
-                                       32,
-                                       5,
-                                       &mwmhints));
-    } else {
-        Q_XCB_CALL(xcb_delete_property(xcb_connection(), m_window, atom(QXcbAtom::_MOTIF_WM_HINTS)));
-    }
+    setMotifWmHints(connection(), m_window, mwmhints);
+}
 
-    if (popup || tooltip) {
-        const quint32 mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_SAVE_UNDER;
-        const quint32 values[] = { true, true };
+void QXcbWindow::changeNetWmState(bool set, xcb_atom_t one, xcb_atom_t two)
+{
+    xcb_client_message_event_t event;
+
+    event.response_type = XCB_CLIENT_MESSAGE;
+    event.format = 32;
+    event.window = m_window;
+    event.type = atom(QXcbAtom::_NET_WM_STATE);
+    event.data.data32[0] = set ? 1 : 0;
+    event.data.data32[1] = one;
+    event.data.data32[2] = two;
+    event.data.data32[3] = 0;
+    event.data.data32[4] = 0;
+
+    Q_XCB_CALL(xcb_send_event(xcb_connection(), 0, m_screen->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+}
+
+Qt::WindowState QXcbWindow::setWindowState(Qt::WindowState state)
+{
+    if (state == m_windowState)
+        return state;
+
+    // unset old state
+    switch (m_windowState) {
+    case Qt::WindowMinimized:
+        Q_XCB_CALL(xcb_map_window(xcb_connection(), m_window));
+        break;
+    case Qt::WindowMaximized:
+        changeNetWmState(false,
+                         atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ),
+                         atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+        break;
+    case Qt::WindowFullScreen:
+        changeNetWmState(false, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+        break;
+    default:
+        break;
+    }
 
-        Q_XCB_CALL(xcb_change_window_attributes(xcb_connection(), m_window, mask, values));
+    // set new state
+    switch (state) {
+    case Qt::WindowMinimized:
+        {
+            xcb_client_message_event_t event;
+
+            event.response_type = XCB_CLIENT_MESSAGE;
+            event.format = 32;
+            event.window = m_window;
+            event.type = atom(QXcbAtom::WM_CHANGE_STATE);
+            event.data.data32[0] = XCB_WM_STATE_ICONIC;
+            event.data.data32[1] = 0;
+            event.data.data32[2] = 0;
+            event.data.data32[3] = 0;
+            event.data.data32[4] = 0;
+
+            Q_XCB_CALL(xcb_send_event(xcb_connection(), 0, m_screen->root(), XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (const char *)&event));
+        }
+        break;
+    case Qt::WindowMaximized:
+        changeNetWmState(true,
+                         atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ),
+                         atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+        break;
+    case Qt::WindowFullScreen:
+        changeNetWmState(true, atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+        break;
+    case Qt::WindowNoState:
+        break;
+    default:
+        break;
     }
 
-    return QPlatformWindow::setWindowFlags(flags);
+    connection()->sync();
+
+    m_windowState = state;
+    return m_windowState;
 }
 
-void QXcbWindow::setNetWmWindowTypes(Qt::WindowFlags flags)
+void QXcbWindow::setNetWmWindowFlags(Qt::WindowFlags flags)
 {
     // in order of decreasing priority
     QVector<uint> windowTypes;
@@ -452,6 +709,90 @@ void QXcbWindow::setNetWmWindowTypes(Qt::WindowFlags flags)
                                    windowTypes.count(), windowTypes.constData()));
 }
 
+void QXcbWindow::updateMotifWmHintsBeforeMap()
+{
+    QtMotifWmHints mwmhints = getMotifWmHints(connection(), m_window);
+
+    if (window()->windowModality() != Qt::NonModal) {
+        switch (window()->windowModality()) {
+        case Qt::WindowModal:
+            mwmhints.input_mode = MWM_INPUT_PRIMARY_APPLICATION_MODAL;
+            break;
+        case Qt::ApplicationModal:
+        default:
+            mwmhints.input_mode = MWM_INPUT_FULL_APPLICATION_MODAL;
+            break;
+        }
+        mwmhints.flags |= MWM_HINTS_INPUT_MODE;
+    } else {
+        mwmhints.input_mode = MWM_INPUT_MODELESS;
+        mwmhints.flags &= ~MWM_HINTS_INPUT_MODE;
+    }
+
+    if (window()->minimumSize() == window()->maximumSize()) {
+        // fixed size, remove the resize handle (since mwm/dtwm
+        // isn't smart enough to do it itself)
+        mwmhints.flags |= MWM_HINTS_FUNCTIONS;
+        if (mwmhints.functions == MWM_FUNC_ALL) {
+            mwmhints.functions = MWM_FUNC_MOVE;
+        } else {
+            mwmhints.functions &= ~MWM_FUNC_RESIZE;
+        }
+
+        if (mwmhints.decorations == MWM_DECOR_ALL) {
+            mwmhints.flags |= MWM_HINTS_DECORATIONS;
+            mwmhints.decorations = (MWM_DECOR_BORDER
+                                    | MWM_DECOR_TITLE
+                                    | MWM_DECOR_MENU);
+        } else {
+            mwmhints.decorations &= ~MWM_DECOR_RESIZEH;
+        }
+    }
+
+    if (window()->windowFlags() & Qt::WindowMinimizeButtonHint) {
+        mwmhints.flags |= MWM_HINTS_DECORATIONS;
+        mwmhints.decorations |= MWM_DECOR_MINIMIZE;
+        mwmhints.functions |= MWM_FUNC_MINIMIZE;
+    }
+    if (window()->windowFlags() & Qt::WindowMaximizeButtonHint) {
+        mwmhints.flags |= MWM_HINTS_DECORATIONS;
+        mwmhints.decorations |= MWM_DECOR_MAXIMIZE;
+        mwmhints.functions |= MWM_FUNC_MAXIMIZE;
+    }
+    if (window()->windowFlags() & Qt::WindowCloseButtonHint)
+        mwmhints.functions |= MWM_FUNC_CLOSE;
+
+    setMotifWmHints(connection(), m_window, mwmhints);
+}
+
+void QXcbWindow::updateNetWmStateBeforeMap()
+{
+    QVector<xcb_atom_t> netWmState;
+
+    Qt::WindowFlags flags = window()->windowFlags();
+    if (flags & Qt::WindowStaysOnTopHint) {
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_ABOVE));
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP));
+    } else if (flags & Qt::WindowStaysOnBottomHint) {
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_BELOW));
+    }
+
+    if (window()->windowState() & Qt::WindowFullScreen) {
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
+    }
+
+    if (window()->windowState() & Qt::WindowMaximized) {
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ));
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
+    }
+
+    if (window()->windowModality() != Qt::NonModal) {
+        netWmState.append(atom(QXcbAtom::_NET_WM_STATE_MODAL));
+    }
+
+    setNetWmState(netWmState);
+}
+
 WId QXcbWindow::winId() const
 {
     return m_window;
@@ -459,8 +800,13 @@ WId QXcbWindow::winId() const
 
 void QXcbWindow::setParent(const QPlatformWindow *parent)
 {
+    // re-create for compatibility
+    create();
+
     QPoint topLeft = geometry().topLeft();
-    Q_XCB_CALL(xcb_reparent_window(xcb_connection(), window(), static_cast<const QXcbWindow *>(parent)->window(), topLeft.x(), topLeft.y()));
+
+    xcb_window_t xcb_parent_id = parent ? static_cast<const QXcbWindow *>(parent)->xcb_window() : m_screen->root();
+    Q_XCB_CALL(xcb_reparent_window(xcb_connection(), xcb_window(), xcb_parent_id, topLeft.x(), topLeft.y()));
 }
 
 void QXcbWindow::setWindowTitle(const QString &title)
@@ -490,6 +836,37 @@ void QXcbWindow::lower()
     Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, values));
 }
 
+void QXcbWindow::propagateSizeHints()
+{
+    // update WM_NORMAL_HINTS
+    xcb_size_hints_t hints;
+
+    QRect rect = geometry();
+
+    xcb_size_hints_set_position(&hints, true, rect.x(), rect.y());
+    xcb_size_hints_set_size(&hints, true, rect.width(), rect.height());
+
+    QWindow *win = window();
+
+    QSize minimumSize = win->minimumSize();
+    QSize maximumSize = win->maximumSize();
+    QSize baseSize = win->baseSize();
+    QSize sizeIncrement = win->sizeIncrement();
+
+    if (minimumSize.width() > 0 || minimumSize.height() > 0)
+        xcb_size_hints_set_min_size(&hints, minimumSize.width(), minimumSize.height());
+
+    if (maximumSize.width() < QWINDOWSIZE_MAX || maximumSize.height() < QWINDOWSIZE_MAX)
+        xcb_size_hints_set_max_size(&hints, maximumSize.width(), maximumSize.height());
+
+    if (sizeIncrement.width() > 0 || sizeIncrement.height() > 0) {
+        xcb_size_hints_set_base_size(&hints, baseSize.width(), baseSize.height());
+        xcb_size_hints_set_resize_inc(&hints, sizeIncrement.width(), sizeIncrement.height());
+    }
+
+    xcb_set_wm_normal_hints(xcb_connection(), m_window, &hints);
+}
+
 void QXcbWindow::requestActivateWindow()
 {
     Q_XCB_CALL(xcb_set_input_focus(xcb_connection(), XCB_INPUT_FOCUS_PARENT, m_window, XCB_TIME_CURRENT_TIME));
@@ -498,17 +875,17 @@ void QXcbWindow::requestActivateWindow()
 
 QPlatformGLContext *QXcbWindow::glContext() const
 {
-    if (!QApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)) {
+    if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::OpenGL)) {
         printf("no opengl\n");
         return 0;
     }
     if (!m_context) {
 #if defined(XCB_USE_GLX)
         QXcbWindow *that = const_cast<QXcbWindow *>(this);
-        that->m_context = new QGLXContext(m_window, m_screen, widget()->platformWindowFormat());
+        that->m_context = new QGLXContext(m_window, m_screen, window()->requestedWindowFormat());
 #elif defined(XCB_USE_EGL)
         EGLDisplay display = connection()->egl_display();
-        EGLConfig config = q_configFromQPlatformWindowFormat(display,widget()->platformWindowFormat(),true);
+        EGLConfig config = q_configFromQPlatformWindowFormat(display,window()->requestedWindowFormat(),true);
         QVector<EGLint> eglContextAttrs;
         eglContextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
         eglContextAttrs.append(2);
@@ -527,11 +904,11 @@ QPlatformGLContext *QXcbWindow::glContext() const
 
 void QXcbWindow::handleExposeEvent(const xcb_expose_event_t *event)
 {
-    QWindowSurface *surface = widget()->windowSurface();
+    QWindowSurface *surface = window()->surface();
     if (surface) {
         QRect rect(event->x, event->y, event->width, event->height);
 
-        surface->flush(widget(), rect, QPoint());
+        surface->flush(window(), rect, QPoint());
     }
 }
 
@@ -539,7 +916,7 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
 {
     if (event->format == 32 && event->type == atom(QXcbAtom::WM_PROTOCOLS)) {
         if (event->data.data32[0] == atom(QXcbAtom::WM_DELETE_WINDOW)) {
-            QWindowSystemInterface::handleCloseEvent(widget());
+            QWindowSystemInterface::handleCloseEvent(window());
         } else if (event->data.data32[0] == atom(QXcbAtom::_NET_WM_PING)) {
             xcb_client_message_event_t reply = *event;
 
@@ -575,7 +952,7 @@ void QXcbWindow::handleConfigureNotifyEvent(const xcb_configure_notify_event_t *
         return;
 
     QPlatformWindow::setGeometry(rect);
-    QWindowSystemInterface::handleGeometryChange(widget(), rect);
+    QWindowSystemInterface::handleGeometryChange(window(), rect);
 
 #if XCB_USE_DRI2
     if (m_context)
@@ -623,7 +1000,7 @@ void QXcbWindow::handleButtonPressEvent(const xcb_button_press_event_t *event)
                      && (modifiers & Qt::AltModifier))
                     || (event->detail == 6 || event->detail == 7));
 
-        QWindowSystemInterface::handleWheelEvent(widget(), event->time,
+        QWindowSystemInterface::handleWheelEvent(window(), event->time,
                                                  local, global, delta, hor ? Qt::Horizontal : Qt::Vertical);
         return;
     }
@@ -654,22 +1031,35 @@ void QXcbWindow::handleMouseEvent(xcb_button_t detail, uint16_t state, xcb_times
 
     buttons ^= button; // X event uses state *before*, Qt uses state *after*
 
-    QWindowSystemInterface::handleMouseEvent(widget(), time, local, global, buttons);
+    QWindowSystemInterface::handleMouseEvent(window(), time, local, global, buttons);
 }
 
-void QXcbWindow::handleEnterNotifyEvent(const xcb_enter_notify_event_t *)
+void QXcbWindow::handleEnterNotifyEvent(const xcb_enter_notify_event_t *event)
 {
-    QWindowSystemInterface::handleEnterEvent(widget());
+    if ((event->mode != XCB_NOTIFY_MODE_NORMAL && event->mode != XCB_NOTIFY_MODE_UNGRAB)
+        || event->detail == XCB_NOTIFY_DETAIL_VIRTUAL
+        || event->detail == XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL)
+    {
+        return;
+    }
+
+    QWindowSystemInterface::handleEnterEvent(window());
 }
 
-void QXcbWindow::handleLeaveNotifyEvent(const xcb_leave_notify_event_t *)
+void QXcbWindow::handleLeaveNotifyEvent(const xcb_leave_notify_event_t *event)
 {
-    QWindowSystemInterface::handleLeaveEvent(widget());
+    if ((event->mode != XCB_NOTIFY_MODE_NORMAL && event->mode != XCB_NOTIFY_MODE_UNGRAB)
+        || event->detail == XCB_NOTIFY_DETAIL_INFERIOR)
+    {
+        return;
+    }
+
+    QWindowSystemInterface::handleLeaveEvent(window());
 }
 
 void QXcbWindow::handleFocusInEvent(const xcb_focus_in_event_t *)
 {
-    QWindowSystemInterface::handleWindowActivated(widget());
+    QWindowSystemInterface::handleWindowActivated(window());
 }
 
 void QXcbWindow::handleFocusOutEvent(const xcb_focus_out_event_t *)
diff --git a/src/plugins/platforms/xcb/qxcbwindow.h b/src/plugins/platforms/xcb/qxcbwindow.h
index 69d0bc2f1d..2260832ade 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.h
+++ b/src/plugins/platforms/xcb/qxcbwindow.h
@@ -43,7 +43,7 @@
 #define QXCBWINDOW_H
 
 #include <QtGui/QPlatformWindow>
-#include <QtGui/QPlatformWindowFormat>
+#include <QtGui/QWindowFormat>
 #include <QtGui/QImage>
 
 #include <xcb/xcb.h>
@@ -56,25 +56,27 @@ class QXcbScreen;
 class QXcbWindow : public QXcbObject, public QPlatformWindow
 {
 public:
-    QXcbWindow(QWidget *tlw);
+    QXcbWindow(QWindow *window);
     ~QXcbWindow();
 
     void setGeometry(const QRect &rect);
 
     void setVisible(bool visible);
     Qt::WindowFlags setWindowFlags(Qt::WindowFlags flags);
+    Qt::WindowState setWindowState(Qt::WindowState state);
     WId winId() const;
     void setParent(const QPlatformWindow *window);
 
     void setWindowTitle(const QString &title);
     void raise();
     void lower();
+    void propagateSizeHints();
 
     void requestActivateWindow();
 
     QPlatformGLContext *glContext() const;
 
-    xcb_window_t window() const { return m_window; }
+    xcb_window_t xcb_window() const { return m_window; }
     uint depth() const { return m_depth; }
     QImage::Format format() const { return m_format; }
 
@@ -95,7 +97,22 @@ public:
     void updateSyncRequestCounter();
 
 private:
-    void setNetWmWindowTypes(Qt::WindowFlags flags);
+    void changeNetWmState(bool set, xcb_atom_t one, xcb_atom_t two = 0);
+    QVector<xcb_atom_t> getNetWmState();
+    void setNetWmState(const QVector<xcb_atom_t> &atoms);
+    void printNetWmState(const QVector<xcb_atom_t> &state);
+
+    void setNetWmWindowFlags(Qt::WindowFlags flags);
+    void setMotifWindowFlags(Qt::WindowFlags flags);
+
+    void updateMotifWmHintsBeforeMap();
+    void updateNetWmStateBeforeMap();
+
+    void create();
+    void destroy();
+
+    void show();
+    void hide();
 
     QXcbScreen *m_screen;
 
@@ -109,6 +126,7 @@ private:
     xcb_sync_counter_t m_syncCounter;
 
     bool m_hasReceivedSyncRequest;
+    Qt::WindowState m_windowState;
 };
 
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbwindowsurface.cpp b/src/plugins/platforms/xcb/qxcbwindowsurface.cpp
index 4fcd207df3..61c2d9bb36 100644
--- a/src/plugins/platforms/xcb/qxcbwindowsurface.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindowsurface.cpp
@@ -168,12 +168,12 @@ void QXcbShmImage::preparePaint(const QRegion &region)
     }
 }
 
-QXcbWindowSurface::QXcbWindowSurface(QWidget *widget, bool setDefaultSurface)
-    : QWindowSurface(widget, setDefaultSurface)
+QXcbWindowSurface::QXcbWindowSurface(QWindow *window, bool setDefaultSurface)
+    : QWindowSurface(window, setDefaultSurface)
     , m_image(0)
     , m_syncingResize(false)
 {
-    QXcbScreen *screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(widget));
+    QXcbScreen *screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWindow(window));
     setConnection(screen->connection());
 }
 
@@ -206,7 +206,7 @@ void QXcbWindowSurface::endPaint(const QRegion &)
 {
 }
 
-void QXcbWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoint &offset)
+void QXcbWindowSurface::flush(QWindow *window, const QRegion &region, const QPoint &offset)
 {
     QRect bounds = region.boundingRect();
 
@@ -215,14 +215,11 @@ void QXcbWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoi
 
     Q_XCB_NOOP(connection());
 
-    QXcbWindow *window = static_cast<QXcbWindow *>(widget->window()->platformWindow());
-
-    extern QWidgetData* qt_widget_data(QWidget *);
-    QPoint widgetOffset = qt_qwidget_data(widget)->wrect.topLeft();
+    QXcbWindow *platformWindow = static_cast<QXcbWindow *>(window->handle());
 
     QVector<QRect> rects = region.rects();
     for (int i = 0; i < rects.size(); ++i)
-        m_image->put(window->window(), rects.at(i).topLeft() - widgetOffset, rects.at(i).translated(offset));
+        m_image->put(platformWindow->xcb_window(), rects.at(i).topLeft(), rects.at(i).translated(offset));
 
     Q_XCB_NOOP(connection());
 
@@ -230,7 +227,7 @@ void QXcbWindowSurface::flush(QWidget *widget, const QRegion &region, const QPoi
         xcb_flush(xcb_connection());
         connection()->sync();
         m_syncingResize = false;
-        window->updateSyncRequestCounter();
+        platformWindow->updateSyncRequestCounter();
     }
 }
 
@@ -242,8 +239,8 @@ void QXcbWindowSurface::resize(const QSize &size)
     Q_XCB_NOOP(connection());
     QWindowSurface::resize(size);
 
-    QXcbScreen *screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWidget(window()));
-    QXcbWindow* win = static_cast<QXcbWindow *>(window()->platformWindow());
+    QXcbScreen *screen = static_cast<QXcbScreen *>(QPlatformScreen::platformScreenForWindow(window()));
+    QXcbWindow* win = static_cast<QXcbWindow *>(window()->handle());
 
     delete m_image;
     m_image = new QXcbShmImage(screen, size, win->depth(), win->format());
diff --git a/src/plugins/platforms/xcb/qxcbwindowsurface.h b/src/plugins/platforms/xcb/qxcbwindowsurface.h
index 5f61815b65..8f401d94a3 100644
--- a/src/plugins/platforms/xcb/qxcbwindowsurface.h
+++ b/src/plugins/platforms/xcb/qxcbwindowsurface.h
@@ -53,11 +53,11 @@ class QXcbShmImage;
 class QXcbWindowSurface : public QXcbObject, public QWindowSurface
 {
 public:
-    QXcbWindowSurface(QWidget *widget, bool setDefaultSurface = true);
+    QXcbWindowSurface(QWindow *widget, bool setDefaultSurface = true);
     ~QXcbWindowSurface();
 
     QPaintDevice *paintDevice();
-    void flush(QWidget *widget, const QRegion &region, const QPoint &offset);
+    void flush(QWindow *window, const QRegion &region, const QPoint &offset);
     void resize(const QSize &size);
     bool scroll(const QRegion &area, int dx, int dy);
 
diff --git a/src/plugins/platforms/xcb/xcb.pro b/src/plugins/platforms/xcb/xcb.pro
index 139f5c9591..93a226bd06 100644
--- a/src/plugins/platforms/xcb/xcb.pro
+++ b/src/plugins/platforms/xcb/xcb.pro
@@ -25,6 +25,8 @@ HEADERS = \
         qxcbwindowsurface.h \
         qxcbnativeinterface.h
 
+QT += gui-private core-private
+
 contains(QT_CONFIG, opengl) {
     QT += opengl