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

Conflicts:
	src/corelib/io/io.pri
	src/corelib/io/qdatastream.cpp
	src/corelib/io/qdatastream.h
	src/network/socket/qabstractsocket.cpp
	src/plugins/platforminputcontexts/ibus/qibusplatforminputcontext.cpp
	src/plugins/platforms/cocoa/qcocoaaccessibilityelement.h
	src/widgets/styles/qgtkstyle.cpp
	tests/auto/corelib/mimetypes/qmimedatabase/qmimedatabase-cache/qmimedatabase-cache.pro
	tests/auto/corelib/mimetypes/qmimedatabase/qmimedatabase-xml/qmimedatabase-xml.pro
	tests/auto/dbus/qdbusconnection/qdbusconnection.pro
	tests/auto/dbus/qdbuspendingcall/tst_qdbuspendingcall.cpp
	tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp

Change-Id: I347549a024eb5bfa986699e0a11f96cc55c797a7

8 files changed, 268 insertions, 177 deletions

diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index 15d3575e60..c35b019f7e 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -107,6 +107,24 @@ Q_LOGGING_CATEGORY(lcQpaScreen, "qt.qpa.screen")
 #define XCB_GE_GENERIC 35
 #endif
 
+// Starting from the xcb version 1.9.3 struct xcb_ge_event_t has changed:
+// - "pad0" became "extension"
+// - "pad1" and "pad" became "pad0"
+// New and old version of this struct share the following fields:
+typedef struct qt_xcb_ge_event_t {
+    uint8_t  response_type;
+    uint8_t  extension;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t event_type;
+} qt_xcb_ge_event_t;
+
+static inline bool isXIEvent(xcb_generic_event_t *event, int opCode)
+{
+    qt_xcb_ge_event_t *e = (qt_xcb_ge_event_t *)event;
+    return e->extension == opCode;
+}
+
 #ifdef XCB_USE_XLIB
 static const char * const xcbConnectionErrors[] = {
     "No error", /* Error 0 */
@@ -305,13 +323,10 @@ void QXcbConnection::updateScreens(const xcb_randr_notify_event_t *event)
                     screen->updateRefreshRate(output.mode);
 
                 // If the screen became primary, reshuffle the order in QGuiApplicationPrivate
-                // TODO: add a proper mechanism for updating primary screen
                 if (!wasPrimary && screen->isPrimary()) {
-                    QScreen *realScreen = static_cast<QPlatformScreen*>(screen)->screen();
-                    QGuiApplicationPrivate::screen_list.removeOne(realScreen);
-                    QGuiApplicationPrivate::screen_list.prepend(realScreen);
-                    m_screens.removeOne(screen);
-                    m_screens.prepend(screen);
+                    const int idx = m_screens.indexOf(screen);
+                    m_screens.swap(0, idx);
+                    QXcbIntegration::instance()->setPrimaryScreen(screen);
                 }
                 qCDebug(lcQpaScreen) << "output has changed" << screen;
             }
@@ -590,9 +605,6 @@ QXcbConnection::QXcbConnection(QXcbNativeInterface *nativeInterface, bool canGra
         qCDebug(QT_XCB_GLINTEGRATION) << "Failed to create xcb gl-integration";
 
     sync();
-
-    if (qEnvironmentVariableIsEmpty("QT_IM_MODULE"))
-        qputenv("QT_IM_MODULE", QByteArray("compose"));
 }
 
 QXcbConnection::~QXcbConnection()
@@ -1115,7 +1127,7 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
 #if defined(XCB_USE_XINPUT2)
         case XCB_GE_GENERIC:
             // Here the windowEventListener is invoked from xi2HandleEvent()
-            if (m_xi2Enabled)
+            if (m_xi2Enabled && isXIEvent(event, m_xiOpCode))
                 xi2HandleEvent(reinterpret_cast<xcb_ge_event_t *>(event));
             break;
 #endif
@@ -1288,10 +1300,12 @@ void QXcbConnection::sendConnectionEvent(QXcbAtom::Atom a, uint id)
     memset(&event, 0, sizeof(event));
 
     const xcb_window_t eventListener = xcb_generate_id(m_connection);
+    xcb_screen_iterator_t it = xcb_setup_roots_iterator(m_setup);
+    xcb_screen_t *screen = it.data;
     Q_XCB_CALL(xcb_create_window(m_connection, XCB_COPY_FROM_PARENT,
-                                 eventListener, m_screens.at(0)->root(),
+                                 eventListener, screen->root,
                                  0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_ONLY,
-                                 m_screens.at(0)->screen()->root_visual, 0, 0));
+                                 screen->root_visual, 0, 0));
 
     event.response_type = XCB_CLIENT_MESSAGE;
     event.format = 32;
@@ -1437,6 +1451,105 @@ void *QXcbConnection::createVisualInfoForDefaultVisualId() const
 
 #endif
 
+#if defined(XCB_USE_XINPUT2)
+// it is safe to cast XI_* events here as long as we are only touching the first 32 bytes,
+// after that position event needs memmove, see xi2PrepareXIGenericDeviceEvent
+static inline bool isXIType(xcb_generic_event_t *event, int opCode, uint16_t type)
+{
+    if (!isXIEvent(event, opCode))
+        return false;
+
+    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
+    return xiEvent->evtype == type;
+}
+#endif
+static inline bool isValid(xcb_generic_event_t *event)
+{
+    return event && (event->response_type & ~0x80);
+}
+
+/*! \internal
+
+    Compresses events of the same type to avoid swamping the event queue.
+    If event compression is not desired there are several options what developers can do:
+
+    1) Write responsive applications. We drop events that have been buffered in the event
+       queue while waiting on unresponsive GUI thread.
+    2) Use QAbstractNativeEventFilter to get all events from X connection. This is not optimal
+       because it requires working with native event types.
+    3) Or add public API to Qt for disabling event compression QTBUG-44964
+
+*/
+bool QXcbConnection::compressEvent(xcb_generic_event_t *event, int currentIndex, QXcbEventArray *eventqueue) const
+{
+    uint responseType = event->response_type & ~0x80;
+    int nextIndex = currentIndex + 1;
+
+    if (responseType == XCB_MOTION_NOTIFY) {
+        // compress XCB_MOTION_NOTIFY notify events
+        for (int j = nextIndex; j < eventqueue->size(); ++j) {
+            xcb_generic_event_t *next = eventqueue->at(j);
+            if (!isValid(next))
+                continue;
+            if (next->response_type == XCB_MOTION_NOTIFY)
+                return true;
+        }
+        return false;
+    }
+#if defined(XCB_USE_XINPUT2)
+    // compress XI_* events
+    if (responseType == XCB_GE_GENERIC) {
+        if (!m_xi2Enabled)
+            return false;
+
+        // compress XI_Motion
+        if (isXIType(event, m_xiOpCode, XI_Motion)) {
+            for (int j = nextIndex; j < eventqueue->size(); ++j) {
+                xcb_generic_event_t *next = eventqueue->at(j);
+                if (!isValid(next))
+                    continue;
+                if (isXIType(next, m_xiOpCode, XI_Motion))
+                    return true;
+            }
+            return false;
+        }
+#ifdef XCB_USE_XINPUT22
+        // compress XI_TouchUpdate for the same touch point id
+        if (isXIType(event, m_xiOpCode, XI_TouchUpdate)) {
+            xXIDeviceEvent *xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
+            uint32_t id = xiDeviceEvent->detail % INT_MAX;
+            for (int j = nextIndex; j < eventqueue->size(); ++j) {
+                xcb_generic_event_t *next = eventqueue->at(j);
+                if (!isValid(next))
+                    continue;
+                if (isXIType(next, m_xiOpCode, XI_TouchUpdate)) {
+                    xXIDeviceEvent *xiDeviceNextEvent = reinterpret_cast<xXIDeviceEvent *>(next);
+                    if (id == xiDeviceNextEvent->detail % INT_MAX)
+                        return true;
+                }
+            }
+            return false;
+        }
+#endif
+        return false;
+    }
+#endif
+    if (responseType == XCB_CONFIGURE_NOTIFY) {
+        // compress multiple configure notify events for the same window
+        for (int j = nextIndex; j < eventqueue->size(); ++j) {
+            xcb_generic_event_t *next = eventqueue->at(j);
+            if (isValid(next) && next->response_type == XCB_CONFIGURE_NOTIFY
+                && ((xcb_configure_notify_event_t *)next)->event == ((xcb_configure_notify_event_t*)event)->event)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    return false;
+}
+
 void QXcbConnection::processXcbEvents()
 {
     int connection_error = xcb_connection_has_error(xcb_connection());
@@ -1447,61 +1560,39 @@ void QXcbConnection::processXcbEvents()
 
     QXcbEventArray *eventqueue = m_reader->lock();
 
-    for(int i = 0; i < eventqueue->size(); ++i) {
+    for (int i = 0; i < eventqueue->size(); ++i) {
         xcb_generic_event_t *event = eventqueue->at(i);
         if (!event)
             continue;
         QScopedPointer<xcb_generic_event_t, QScopedPointerPodDeleter> eventGuard(event);
         (*eventqueue)[i] = 0;
 
-        uint response_type = event->response_type & ~0x80;
-
-        if (!response_type) {
+        if (!(event->response_type & ~0x80)) {
             handleXcbError((xcb_generic_error_t *)event);
-        } else {
-            if (response_type == XCB_MOTION_NOTIFY) {
-                // compress multiple motion notify events in a row
-                // to avoid swamping the event queue
-                xcb_generic_event_t *next = eventqueue->value(i+1, 0);
-                if (next && (next->response_type & ~0x80) == XCB_MOTION_NOTIFY)
-                    continue;
-            }
+            continue;
+        }
 
-            if (response_type == XCB_CONFIGURE_NOTIFY) {
-                // compress multiple configure notify events for the same window
-                bool found = false;
-                for (int j = i; j < eventqueue->size(); ++j) {
-                    xcb_generic_event_t *other = eventqueue->at(j);
-                    if (other && (other->response_type & ~0x80) == XCB_CONFIGURE_NOTIFY
-                        && ((xcb_configure_notify_event_t *)other)->event == ((xcb_configure_notify_event_t *)event)->event)
-                    {
-                        found = true;
-                        break;
-                    }
-                }
-                if (found)
-                    continue;
-            }
+        if (compressEvent(event, i, eventqueue))
+            continue;
 
-            bool accepted = false;
-            if (clipboard()->processIncr())
-                clipboard()->incrTransactionPeeker(event, accepted);
-            if (accepted)
-                continue;
+        bool accepted = false;
+        if (clipboard()->processIncr())
+            clipboard()->incrTransactionPeeker(event, accepted);
+        if (accepted)
+            continue;
 
-            QVector<PeekFunc>::iterator it = m_peekFuncs.begin();
-            while (it != m_peekFuncs.end()) {
-                // These callbacks return true if the event is what they were
-                // waiting for, remove them from the list in that case.
-                if ((*it)(this, event))
-                    it = m_peekFuncs.erase(it);
-                else
-                    ++it;
-            }
-            m_reader->unlock();
-            handleXcbEvent(event);
-            m_reader->lock();
+        QVector<PeekFunc>::iterator it = m_peekFuncs.begin();
+        while (it != m_peekFuncs.end()) {
+            // These callbacks return true if the event is what they were
+            // waiting for, remove them from the list in that case.
+            if ((*it)(this, event))
+                it = m_peekFuncs.erase(it);
+            else
+                ++it;
         }
+        m_reader->unlock();
+        handleXcbEvent(event);
+        m_reader->lock();
     }
 
     eventqueue->clear();
@@ -1746,7 +1837,8 @@ static const char * xcb_atomnames = {
     "_XSETTINGS_SETTINGS\0"
     "_COMPIZ_DECOR_PENDING\0"
     "_COMPIZ_DECOR_REQUEST\0"
-    "_COMPIZ_DECOR_DELETE_PIXMAP\0" // \0\0 terminates loop.
+    "_COMPIZ_DECOR_DELETE_PIXMAP\0"
+    "_COMPIZ_TOOLKIT_ACTION\0" // \0\0 terminates loop.
 };
 
 QXcbAtom::Atom QXcbConnection::qatom(xcb_atom_t xatom) const
@@ -2043,34 +2135,13 @@ bool QXcbConnection::xi2GetValuatorValueIfSet(void *event, int valuatorNum, doub
     return true;
 }
 
-// Starting from the xcb version 1.9.3 struct xcb_ge_event_t has changed:
-// - "pad0" became "extension"
-// - "pad1" and "pad" became "pad0"
-// New and old version of this struct share the following fields:
-// NOTE: API might change again in the next release of xcb in which case this comment will
-// need to be updated to reflect the reality.
-typedef struct qt_xcb_ge_event_t {
-    uint8_t  response_type;
-    uint8_t  extension;
-    uint16_t sequence;
-    uint32_t length;
-    uint16_t event_type;
-} qt_xcb_ge_event_t;
-
-bool QXcbConnection::xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *ev, int opCode)
-{
-    qt_xcb_ge_event_t *event = (qt_xcb_ge_event_t *)ev;
-    // xGenericEvent has "extension" on the second byte, the same is true for xcb_ge_event_t starting from
-    // the xcb version 1.9.3, prior to that it was called "pad0".
-    if (event->extension == opCode) {
-        // xcb event structs contain stuff that wasn't on the wire, the full_sequence field
-        // adds an extra 4 bytes and generic events cookie data is on the wire right after the standard 32 bytes.
-        // Move this data back to have the same layout in memory as it was on the wire
-        // and allow casting, overwriting the full_sequence field.
-        memmove((char*) event + 32, (char*) event + 36, event->length * 4);
-        return true;
-    }
-    return false;
+void QXcbConnection::xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event)
+{
+    // xcb event structs contain stuff that wasn't on the wire, the full_sequence field
+    // adds an extra 4 bytes and generic events cookie data is on the wire right after the standard 32 bytes.
+    // Move this data back to have the same layout in memory as it was on the wire
+    // and allow casting, overwriting the full_sequence field.
+    memmove((char*) event + 32, (char*) event + 36, event->length * 4);
 }
 #endif // defined(XCB_USE_XINPUT2)
 
diff --git a/src/plugins/platforms/xcb/qxcbconnection.h b/src/plugins/platforms/xcb/qxcbconnection.h
index 4a0348aa0c..6ee32bf600 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@@ -286,6 +286,7 @@ namespace QXcbAtom {
         _COMPIZ_DECOR_PENDING,
         _COMPIZ_DECOR_REQUEST,
         _COMPIZ_DECOR_DELETE_PIXMAP,
+        _COMPIZ_TOOLKIT_ACTION,
 
         NPredefinedAtoms,
 
@@ -522,6 +523,7 @@ private:
     bool checkOutputIsPrimary(xcb_window_t rootWindow, xcb_randr_output_t output);
     void initializeScreens();
     void updateScreens(const xcb_randr_notify_event_t *event);
+    bool compressEvent(xcb_generic_event_t *event, int currentIndex, QXcbEventArray *eventqueue) const;
 
     bool m_xi2Enabled;
     int m_xi2Minor;
@@ -574,7 +576,7 @@ private:
     QHash<int, ScrollingDevice> m_scrollingDevices;
 
     static bool xi2GetValuatorValueIfSet(void *event, int valuatorNum, double *value);
-    static bool xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event, int opCode);
+    static void xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event);
 #endif
 
     xcb_connection_t *m_connection;
diff --git a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
index 5a2ea74258..8097cce709 100644
--- a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
@@ -216,6 +216,12 @@ void QXcbConnection::xi2SetupDevices()
             isTablet = true;
             tabletData.pointerType = QTabletEvent::Pen;
             dbgType = QLatin1String("pen");
+        } else if (name.contains("waltop") && name.contains("tablet")) {
+            // other "Genius" tablets
+            // WALTOP International Corp. Slim Tablet
+            isTablet = true;
+            tabletData.pointerType = QTabletEvent::Pen;
+            dbgType = QLatin1String("pen");
         } else {
             isTablet = false;
         }
@@ -413,8 +419,10 @@ XInput2TouchDeviceData *QXcbConnection::touchDeviceForId(int id)
                     hasRelativeCoords = true;
                     dev->size.setHeight((vci->max - vci->min) * 1000.0 / vci->resolution);
                 } else if (vci->label == atom(QXcbAtom::AbsX)) {
+                    caps |= QTouchDevice::Position;
                     dev->size.setHeight((vci->max - vci->min) * 1000.0 / vci->resolution);
                 } else if (vci->label == atom(QXcbAtom::AbsY)) {
+                    caps |= QTouchDevice::Position;
                     dev->size.setWidth((vci->max - vci->min) * 1000.0 / vci->resolution);
                 }
                 break;
@@ -459,82 +467,81 @@ static inline qreal fixed1616ToReal(FP1616 val)
 
 void QXcbConnection::xi2HandleEvent(xcb_ge_event_t *event)
 {
-    if (xi2PrepareXIGenericDeviceEvent(event, m_xiOpCode)) {
-        xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
-        int sourceDeviceId = xiEvent->deviceid; // may be the master id
-        xXIDeviceEvent *xiDeviceEvent = 0;
-        QXcbWindowEventListener *eventListener = 0;
+    xi2PrepareXIGenericDeviceEvent(event);
+    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
+    int sourceDeviceId = xiEvent->deviceid; // may be the master id
+    xXIDeviceEvent *xiDeviceEvent = 0;
+    QXcbWindowEventListener *eventListener = 0;
 
-        switch (xiEvent->evtype) {
-        case XI_ButtonPress:
-        case XI_ButtonRelease:
-        case XI_Motion:
+    switch (xiEvent->evtype) {
+    case XI_ButtonPress:
+    case XI_ButtonRelease:
+    case XI_Motion:
 #ifdef XCB_USE_XINPUT22
-        case XI_TouchBegin:
-        case XI_TouchUpdate:
-        case XI_TouchEnd:
+    case XI_TouchBegin:
+    case XI_TouchUpdate:
+    case XI_TouchEnd:
 #endif
-        {
-            xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
-            eventListener = windowEventListenerFromId(xiDeviceEvent->event);
-            if (eventListener) {
-                long result = 0;
-                if (eventListener->handleGenericEvent(reinterpret_cast<xcb_generic_event_t *>(event), &result))
-                    return;
-            }
-            sourceDeviceId = xiDeviceEvent->sourceid; // use the actual device id instead of the master
-            break;
-        }
-        case XI_HierarchyChanged:
-            xi2HandleHierachyEvent(xiEvent);
-            return;
-        case XI_DeviceChanged:
-            xi2HandleDeviceChangedEvent(xiEvent);
-            return;
-        default:
-            break;
+    {
+        xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
+        eventListener = windowEventListenerFromId(xiDeviceEvent->event);
+        if (eventListener) {
+            long result = 0;
+            if (eventListener->handleGenericEvent(reinterpret_cast<xcb_generic_event_t *>(event), &result))
+                return;
         }
+        sourceDeviceId = xiDeviceEvent->sourceid; // use the actual device id instead of the master
+        break;
+    }
+    case XI_HierarchyChanged:
+        xi2HandleHierachyEvent(xiEvent);
+        return;
+    case XI_DeviceChanged:
+        xi2HandleDeviceChangedEvent(xiEvent);
+        return;
+    default:
+        break;
+    }
 
 #ifndef QT_NO_TABLETEVENT
-        for (int i = 0; i < m_tabletData.count(); ++i) {
-            if (m_tabletData.at(i).deviceId == sourceDeviceId) {
-                if (xi2HandleTabletEvent(xiEvent, &m_tabletData[i], eventListener))
-                    return;
-            }
+    for (int i = 0; i < m_tabletData.count(); ++i) {
+        if (m_tabletData.at(i).deviceId == sourceDeviceId) {
+            if (xi2HandleTabletEvent(xiEvent, &m_tabletData[i], eventListener))
+                return;
         }
+    }
 #endif // QT_NO_TABLETEVENT
 
 #ifdef XCB_USE_XINPUT21
-        QHash<int, ScrollingDevice>::iterator device = m_scrollingDevices.find(sourceDeviceId);
-        if (device != m_scrollingDevices.end())
-            xi2HandleScrollEvent(xiEvent, device.value());
+    QHash<int, ScrollingDevice>::iterator device = m_scrollingDevices.find(sourceDeviceId);
+    if (device != m_scrollingDevices.end())
+        xi2HandleScrollEvent(xiEvent, device.value());
 #endif // XCB_USE_XINPUT21
 
 #ifdef XCB_USE_XINPUT22
-        if (xiDeviceEvent) {
-            switch (xiDeviceEvent->evtype) {
-            case XI_ButtonPress:
-            case XI_ButtonRelease:
-            case XI_Motion:
-                if (xi2MouseEvents() && eventListener && !(xiDeviceEvent->flags & XIPointerEmulated))
-                    eventListener->handleXIMouseEvent(event);
-                break;
+    if (xiDeviceEvent) {
+        switch (xiDeviceEvent->evtype) {
+        case XI_ButtonPress:
+        case XI_ButtonRelease:
+        case XI_Motion:
+            if (xi2MouseEvents() && eventListener && !(xiDeviceEvent->flags & XIPointerEmulated))
+                eventListener->handleXIMouseEvent(event);
+            break;
 
-            case XI_TouchBegin:
-            case XI_TouchUpdate:
-            case XI_TouchEnd:
-                if (Q_UNLIKELY(lcQpaXInput().isDebugEnabled()))
-                    qCDebug(lcQpaXInput, "XI2 touch event type %d seq %d detail %d pos %6.1f, %6.1f root pos %6.1f, %6.1f on window %x",
-                            event->event_type, xiDeviceEvent->sequenceNumber, xiDeviceEvent->detail,
-                            fixed1616ToReal(xiDeviceEvent->event_x), fixed1616ToReal(xiDeviceEvent->event_y),
-                            fixed1616ToReal(xiDeviceEvent->root_x), fixed1616ToReal(xiDeviceEvent->root_y),xiDeviceEvent->event);
-                if (QXcbWindow *platformWindow = platformWindowFromId(xiDeviceEvent->event))
-                    xi2ProcessTouch(xiDeviceEvent, platformWindow);
-                break;
-            }
+        case XI_TouchBegin:
+        case XI_TouchUpdate:
+        case XI_TouchEnd:
+            if (Q_UNLIKELY(lcQpaXInput().isDebugEnabled()))
+                qCDebug(lcQpaXInput, "XI2 touch event type %d seq %d detail %d pos %6.1f, %6.1f root pos %6.1f, %6.1f on window %x",
+                        event->event_type, xiDeviceEvent->sequenceNumber, xiDeviceEvent->detail,
+                        fixed1616ToReal(xiDeviceEvent->event_x), fixed1616ToReal(xiDeviceEvent->event_y),
+                        fixed1616ToReal(xiDeviceEvent->root_x), fixed1616ToReal(xiDeviceEvent->root_y),xiDeviceEvent->event);
+            if (QXcbWindow *platformWindow = platformWindowFromId(xiDeviceEvent->event))
+                xi2ProcessTouch(xiDeviceEvent, platformWindow);
+            break;
         }
-#endif // XCB_USE_XINPUT22
     }
+#endif // XCB_USE_XINPUT22
 }
 
 #ifdef XCB_USE_XINPUT22
@@ -967,15 +974,6 @@ bool QXcbConnection::xi2HandleTabletEvent(void *event, TabletData *tabletData, Q
     xXIGenericDeviceEvent *xiEvent = static_cast<xXIGenericDeviceEvent *>(event);
     xXIDeviceEvent *xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(xiEvent);
 
-#ifdef XCB_USE_XINPUT22
-    // Synthesize mouse events since otherwise there are no mouse events from
-    // the pen on the XI 2.2+ path.
-    if (xi2MouseEvents() && eventListener)
-        eventListener->handleXIMouseEvent(reinterpret_cast<xcb_ge_event_t *>(event));
-#else
-    Q_UNUSED(eventListener);
-#endif
-
     switch (xiEvent->evtype) {
     case XI_ButtonPress: {
         Qt::MouseButton b = xiToQtMouseButton(xiDeviceEvent->detail);
@@ -1029,9 +1027,8 @@ bool QXcbConnection::xi2HandleTabletEvent(void *event, TabletData *tabletData, Q
                             tabletData->inProximity = true;
                             tabletData->tool = toolIdToTabletDevice(tool);
                             tabletData->serialId = qint64(ptr[_WACSER_USB_ID]) << 32 | qint64(ptr[_WACSER_TOOL_SERIAL]);
-                            QWindowSystemInterface::handleTabletEnterProximityEvent(tabletData->tool,
-                                                                                    tabletData->pointerType,
-                                                                                    tabletData->serialId);
+                            QWindowSystemInterface::handleTabletEnterProximityEvent(ev->time,
+                                tabletData->tool, tabletData->pointerType, tabletData->serialId);
                         } else {
                             tabletData->inProximity = false;
                             tabletData->tool = toolIdToTabletDevice(ptr[_WACSER_LAST_TOOL_ID]);
@@ -1040,9 +1037,8 @@ bool QXcbConnection::xi2HandleTabletEvent(void *event, TabletData *tabletData, Q
                             if (!tabletData->tool)
                                 tabletData->tool = toolIdToTabletDevice(ptr[_WACSER_LAST_TOOL_SERIAL]);
                             tabletData->serialId = qint64(ptr[_WACSER_USB_ID]) << 32 | qint64(ptr[_WACSER_LAST_TOOL_SERIAL]);
-                            QWindowSystemInterface::handleTabletLeaveProximityEvent(tabletData->tool,
-                                                                                    tabletData->pointerType,
-                                                                                    tabletData->serialId);
+                            QWindowSystemInterface::handleTabletLeaveProximityEvent(ev->time,
+                                tabletData->tool, tabletData->pointerType, tabletData->serialId);
                         }
                         // TODO maybe have a hash of tabletData->deviceId to device data so we can
                         // look up the tablet name here, and distinguish multiple tablets
@@ -1060,6 +1056,16 @@ bool QXcbConnection::xi2HandleTabletEvent(void *event, TabletData *tabletData, Q
         handled = false;
         break;
     }
+
+#ifdef XCB_USE_XINPUT22
+    // Synthesize mouse events since otherwise there are no mouse events from
+    // the pen on the XI 2.2+ path.
+    if (xi2MouseEvents() && eventListener)
+        eventListener->handleXIMouseEvent(reinterpret_cast<xcb_ge_event_t *>(event));
+#else
+    Q_UNUSED(eventListener);
+#endif
+
     return handled;
 }
 
@@ -1110,13 +1116,14 @@ void QXcbConnection::xi2ReportTabletEvent(TabletData &tabletData, void *event)
     }
 
     if (Q_UNLIKELY(lcQpaXInput().isDebugEnabled()))
-        qCDebug(lcQpaXInput, "XI2 event on tablet %d with tool %d type %d seq %d detail %d pos %6.1f, %6.1f root pos %6.1f, %6.1f buttons 0x%x pressure %4.2lf tilt %d, %d rotation %6.2lf",
-            tabletData.deviceId, tabletData.tool, ev->evtype, ev->sequenceNumber, ev->detail,
+        qCDebug(lcQpaXInput, "XI2 event on tablet %d with tool %d type %d seq %d detail %d time %d "
+            "pos %6.1f, %6.1f root pos %6.1f, %6.1f buttons 0x%x pressure %4.2lf tilt %d, %d rotation %6.2lf",
+            tabletData.deviceId, tabletData.tool, ev->evtype, ev->sequenceNumber, ev->detail, ev->time,
             fixed1616ToReal(ev->event_x), fixed1616ToReal(ev->event_y),
             fixed1616ToReal(ev->root_x), fixed1616ToReal(ev->root_y),
             (int)tabletData.buttons, pressure, xTilt, yTilt, rotation);
 
-    QWindowSystemInterface::handleTabletEvent(window, local, global,
+    QWindowSystemInterface::handleTabletEvent(window, ev->time, local, global,
                                               tabletData.tool, tabletData.pointerType,
                                               tabletData.buttons, pressure,
                                               xTilt, yTilt, tangentialPressure,
diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp
index a3e646ed7a..de23c59a63 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.cpp
+++ b/src/plugins/platforms/xcb/qxcbdrag.cpp
@@ -444,7 +444,7 @@ void QXcbDrag::move(const QPoint &globalPos)
 
             DEBUG() << "sending Xdnd enter source=" << enter.data.data32[0];
             if (w)
-                handleEnter(w, &enter);
+                handleEnter(w, &enter, current_proxy_target);
             else if (target)
                 xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&enter);
             waiting_for_status = false;
@@ -665,7 +665,7 @@ static bool checkEmbedded(QWidget* w, const XEvent* xe)
 #endif
 
 
-void QXcbDrag::handleEnter(QPlatformWindow *window, const xcb_client_message_event_t *event)
+void QXcbDrag::handleEnter(QPlatformWindow *window, const xcb_client_message_event_t *event, xcb_window_t proxy)
 {
     Q_UNUSED(window);
     DEBUG() << "handleEnter" << window;
@@ -677,6 +677,9 @@ void QXcbDrag::handleEnter(QPlatformWindow *window, const xcb_client_message_eve
         return;
 
     xdnd_dragsource = event->data.data32[0];
+    if (!proxy)
+        proxy = xdndProxy(connection(), xdnd_dragsource);
+    current_proxy_target = proxy ? proxy : xdnd_dragsource;
 
     if (event->data.data32[1] & 1) {
         // get the types from XdndTypeList
@@ -775,7 +778,7 @@ void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message
     if (xdnd_dragsource == connection()->clipboard()->owner())
         handle_xdnd_status(&response);
     else
-        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, xdnd_dragsource,
+        Q_XCB_CALL(xcb_send_event(xcb_connection(), false, current_proxy_target,
                                   XCB_EVENT_MASK_NO_EVENT, (const char *)&response));
 }
 
@@ -967,7 +970,7 @@ void QXcbDrag::handleDrop(QPlatformWindow *, const xcb_client_message_event_t *e
     finished.data.data32[0] = currentWindow ? xcb_window(currentWindow.data()) : XCB_NONE;
     finished.data.data32[1] = response.isAccepted(); // flags
     finished.data.data32[2] = toXdndAction(response.acceptedAction());
-    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, xdnd_dragsource,
+    Q_XCB_CALL(xcb_send_event(xcb_connection(), false, current_proxy_target,
                               XCB_EVENT_MASK_NO_EVENT, (char *)&finished));
 
     xdnd_dragsource = 0;
@@ -1132,7 +1135,11 @@ void QXcbDrag::handleSelectionRequest(const xcb_selection_request_event_t *event
         }
     }
 
-    xcb_send_event(xcb_connection(), false, event->requestor, XCB_EVENT_MASK_NO_EVENT, (const char *)&notify);
+    xcb_window_t proxy_target = xdndProxy(connection(), event->requestor);
+    if (!proxy_target)
+        proxy_target = event->requestor;
+
+    xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&notify);
 }
 
 
diff --git a/src/plugins/platforms/xcb/qxcbdrag.h b/src/plugins/platforms/xcb/qxcbdrag.h
index 699d402ea6..9584c04238 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.h
+++ b/src/plugins/platforms/xcb/qxcbdrag.h
@@ -76,7 +76,7 @@ public:
     void drop(const QPoint &globalPos) Q_DECL_OVERRIDE;
     void endDrag() Q_DECL_OVERRIDE;
 
-    void handleEnter(QPlatformWindow *window, const xcb_client_message_event_t *event);
+    void handleEnter(QPlatformWindow *window, const xcb_client_message_event_t *event, xcb_window_t proxy = 0);
     void handlePosition(QPlatformWindow *w, const xcb_client_message_event_t *event);
     void handleLeave(QPlatformWindow *w, const xcb_client_message_event_t *event);
     void handleDrop(QPlatformWindow *, const xcb_client_message_event_t *event);
diff --git a/src/plugins/platforms/xcb/qxcbintegration.cpp b/src/plugins/platforms/xcb/qxcbintegration.cpp
index fc06f1a7b0..9cedfa77ad 100644
--- a/src/plugins/platforms/xcb/qxcbintegration.cpp
+++ b/src/plugins/platforms/xcb/qxcbintegration.cpp
@@ -268,7 +268,10 @@ void QXcbIntegration::initialize()
 {
     // Perform everything that may potentially need the event dispatcher (timers, socket
     // notifiers) here instead of the constructor.
-    m_inputContext.reset(QPlatformInputContextFactory::create());
+    QString icStr = QPlatformInputContextFactory::requested();
+    if (icStr.isNull())
+        icStr = QLatin1String("compose");
+    m_inputContext.reset(QPlatformInputContextFactory::create(icStr));
 }
 
 void QXcbIntegration::moveToScreen(QWindow *window, int screen)
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index f9a85cdf44..d751c6d48a 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -1971,7 +1971,8 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
         // and other messages.
     } else if (event->type == atom(QXcbAtom::_COMPIZ_DECOR_PENDING)
             || event->type == atom(QXcbAtom::_COMPIZ_DECOR_REQUEST)
-            || event->type == atom(QXcbAtom::_COMPIZ_DECOR_DELETE_PIXMAP)) {
+            || event->type == atom(QXcbAtom::_COMPIZ_DECOR_DELETE_PIXMAP)
+            || event->type == atom(QXcbAtom::_COMPIZ_TOOLKIT_ACTION)) {
         //silence the _COMPIZ messages for now
     } else {
         qWarning() << "QXcbWindow: Unhandled client message:" << connection()->atomName(event->type);
@@ -2208,17 +2209,17 @@ void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event)
 
     switch (ev->evtype) {
     case XI_ButtonPress:
-        qCDebug(lcQpaXInput, "XI2 mouse press, button %d", button);
+        qCDebug(lcQpaXInput, "XI2 mouse press, button %d, time %d", button, ev->time);
         conn->setButton(button, true);
         handleButtonPressEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time);
         break;
     case XI_ButtonRelease:
-        qCDebug(lcQpaXInput, "XI2 mouse release, button %d", button);
+        qCDebug(lcQpaXInput, "XI2 mouse release, button %d, time %d", button, ev->time);
         conn->setButton(button, false);
         handleButtonReleaseEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time);
         break;
     case XI_Motion:
-        qCDebug(lcQpaXInput, "XI2 mouse motion %d,%d", event_x, event_y);
+        qCDebug(lcQpaXInput, "XI2 mouse motion %d,%d, time %d", event_x, event_y, ev->time);
         handleMotionNotifyEvent(event_x, event_y, root_x, root_y, modifiers, ev->time);
         break;
     default:
diff --git a/src/plugins/platforms/xcb/qxcbwmsupport.cpp b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
index 7d31ac7118..82c1c1de77 100644
--- a/src/plugins/platforms/xcb/qxcbwmsupport.cpp
+++ b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
@@ -94,14 +94,14 @@ void QXcbWMSupport::updateVirtualRoots()
     int offset = 0;
     int remaining = 0;
     do {
-        xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, root, atom(QXcbAtom::_NET_VIRTUAL_ROOTS), XCB_ATOM_ATOM, offset, 1024);
+        xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, root, atom(QXcbAtom::_NET_VIRTUAL_ROOTS), XCB_ATOM_WINDOW, offset, 1024);
         xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, NULL);
         if (!reply)
             break;
 
         remaining = 0;
 
-        if (reply->type == XCB_ATOM_ATOM && reply->format == 32) {
+        if (reply->type == XCB_ATOM_WINDOW && reply->format == 32) {
             int len = xcb_get_property_value_length(reply)/sizeof(xcb_window_t);
             xcb_window_t *roots = (xcb_window_t *)xcb_get_property_value(reply);
             int s = net_virtual_roots.size();