diff --git a/platform.cpp b/platform.cpp
index 257d9ea06..e986fd943 100644
--- a/platform.cpp
+++ b/platform.cpp
@@ -1,544 +1,570 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "platform.h"
 
 #include "abstract_output.h"
 #include <config-kwin.h>
 #include "composite.h"
 #include "cursor.h"
 #include "effects.h"
 #include <KCoreAddons>
 #include "overlaywindow.h"
 #include "outline.h"
 #include "pointer_input.h"
 #include "scene.h"
 #include "screens.h"
 #include "screenedge.h"
 #include "wayland_server.h"
 #include "colorcorrection/manager.h"
 
 #include <KWayland/Server/outputconfiguration_interface.h>
 #include <KWayland/Server/outputchangeset.h>
 
+#include <QX11Info>
+
 namespace KWin
 {
 
 Platform::Platform(QObject *parent)
     : QObject(parent)
     , m_eglDisplay(EGL_NO_DISPLAY)
 {
     setSoftWareCursor(false);
     m_colorCorrect = new ColorCorrect::Manager(this);
     connect(Cursors::self(), &Cursors::currentCursorRendered, this, &Platform::cursorRendered);
 }
 
 Platform::~Platform()
 {
     if (m_eglDisplay != EGL_NO_DISPLAY) {
         eglTerminate(m_eglDisplay);
     }
 }
 
 PlatformCursorImage Platform::cursorImage() const
 {
     Cursor* cursor = Cursors::self()->currentCursor();
     return PlatformCursorImage(cursor->image(), cursor->hotspot());
 }
 
 void Platform::hideCursor()
 {
     m_hideCursorCounter++;
     if (m_hideCursorCounter == 1) {
         doHideCursor();
     }
 }
 
 void Platform::doHideCursor()
 {
 }
 
 void Platform::showCursor()
 {
     m_hideCursorCounter--;
     if (m_hideCursorCounter == 0) {
         doShowCursor();
     }
 }
 
 void Platform::doShowCursor()
 {
 }
 
 Screens *Platform::createScreens(QObject *parent)
 {
     Q_UNUSED(parent)
     return nullptr;
 }
 
 OpenGLBackend *Platform::createOpenGLBackend()
 {
     return nullptr;
 }
 
 QPainterBackend *Platform::createQPainterBackend()
 {
     return nullptr;
 }
 
 void Platform::prepareShutdown()
 {
     setOutputsEnabled(false);
 }
 
 Edge *Platform::createScreenEdge(ScreenEdges *edges)
 {
     return new Edge(edges);
 }
 
 void Platform::createPlatformCursor(QObject *parent)
 {
     new InputRedirectionCursor(parent);
 }
 
 void Platform::requestOutputsChange(KWayland::Server::OutputConfigurationInterface *config)
 {
     if (!m_supportsOutputChanges) {
         qCWarning(KWIN_CORE) << "This backend does not support configuration changes.";
         config->setFailed();
         return;
     }
 
     using Enablement = KWayland::Server::OutputDeviceInterface::Enablement;
 
     const auto changes = config->changes();
 
     //process all non-disabling changes
     for (auto it = changes.begin(); it != changes.end(); it++) {
         const KWayland::Server::OutputChangeSet *changeset = it.value();
 
         auto output = findOutput(it.key()->uuid());
         if (!output) {
             qCWarning(KWIN_CORE) << "Could NOT find output matching " << it.key()->uuid();
             continue;
         }
 
         if (changeset->enabledChanged() &&
                 changeset->enabled() == Enablement::Enabled) {
             output->setEnabled(true);
         }
         output->applyChanges(changeset);
     }
 
     //process any disable requests
     for (auto it = changes.begin(); it != changes.end(); it++) {
         const KWayland::Server::OutputChangeSet *changeset = it.value();
 
         if (changeset->enabledChanged() &&
                 changeset->enabled() == Enablement::Disabled) {
             if (enabledOutputs().count() == 1) {
                 // TODO: check beforehand this condition and set failed otherwise
                 // TODO: instead create a dummy output?
                 qCWarning(KWIN_CORE) << "Not disabling final screen" << it.key()->uuid();
                 continue;
             }
             auto output = findOutput(it.key()->uuid());
             if (!output) {
                 qCWarning(KWIN_CORE) << "Could NOT find output matching " << it.key()->uuid();
                 continue;
             }
             output->setEnabled(false);
         }
     }
     emit screens()->changed();
     config->setApplied();
 }
 
 AbstractOutput *Platform::findOutput(const QByteArray &uuid)
 {
     const auto outs = outputs();
     auto it = std::find_if(outs.constBegin(), outs.constEnd(),
         [uuid](AbstractOutput *output) {
             return output->uuid() == uuid; }
     );
     if (it != outs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 void Platform::setSoftWareCursor(bool set)
 {
     if (qEnvironmentVariableIsSet("KWIN_FORCE_SW_CURSOR")) {
         set = true;
     }
     if (m_softWareCursor == set) {
         return;
     }
     m_softWareCursor = set;
     if (m_softWareCursor) {
         connect(Cursors::self(), &Cursors::positionChanged, this, &Platform::triggerCursorRepaint);
         connect(Cursors::self(), &Cursors::currentCursorChanged, this, &Platform::triggerCursorRepaint);
     } else {
         disconnect(Cursors::self(), &Cursors::positionChanged, this, &Platform::triggerCursorRepaint);
         disconnect(Cursors::self(), &Cursors::currentCursorChanged, this, &Platform::triggerCursorRepaint);
     }
 }
 
 void Platform::triggerCursorRepaint()
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(m_cursor.lastRenderedGeometry);
     Compositor::self()->addRepaint(Cursors::self()->currentCursor()->geometry());
 }
 
 void Platform::cursorRendered(const QRect &geometry)
 {
     if (m_softWareCursor) {
         m_cursor.lastRenderedGeometry = geometry;
     }
 }
 
 void Platform::keyboardKeyPressed(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyPressed, time);
 }
 
 void Platform::keyboardKeyReleased(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyReleased, time);
 }
 
 void Platform::keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void Platform::keymapChange(int fd, uint32_t size)
 {
     if (!input()) {
         return;
     }
     input()->processKeymapChange(fd, size);
 }
 
 void Platform::pointerAxisHorizontal(qreal delta, quint32 time, qint32 discreteDelta, InputRedirection::PointerAxisSource source)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisHorizontal, delta, discreteDelta, source, time);
 }
 
 void Platform::pointerAxisVertical(qreal delta, quint32 time, qint32 discreteDelta, InputRedirection::PointerAxisSource source)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisVertical, delta, discreteDelta, source, time);
 }
 
 void Platform::pointerButtonPressed(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonPressed, time);
 }
 
 void Platform::pointerButtonReleased(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonReleased, time);
 }
 
 void Platform::pointerMotion(const QPointF &position, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerMotion(position, time);
 }
 
 void Platform::touchCancel()
 {
     if (!input()) {
         return;
     }
     input()->cancelTouch();
 }
 
 void Platform::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchDown(id, pos, time);
 }
 
 void Platform::touchFrame()
 {
     if (!input()) {
         return;
     }
     input()->touchFrame();
 }
 
 void Platform::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchMotion(id, pos, time);
 }
 
 void Platform::touchUp(qint32 id, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchUp(id, time);
 }
 
 void Platform::processSwipeGestureBegin(int fingerCount, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureBegin(fingerCount, time);
 }
 
 void Platform::processSwipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureUpdate(delta, time);
 }
 
 void Platform::processSwipeGestureEnd(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureEnd(time);
 }
 
 void Platform::processSwipeGestureCancelled(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureCancelled(time);
 }
 
 void Platform::processPinchGestureBegin(int fingerCount, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureBegin(fingerCount, time);
 }
 
 void Platform::processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureUpdate(scale, angleDelta, delta, time);
 }
 
 void Platform::processPinchGestureEnd(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureEnd(time);
 }
 
 void Platform::processPinchGestureCancelled(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureCancelled(time);
 }
 
 void Platform::repaint(const QRect &rect)
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(rect);
 }
 
 void Platform::setReady(bool ready)
 {
     if (m_ready == ready) {
         return;
     }
     m_ready = ready;
     emit readyChanged(m_ready);
 }
 
 void Platform::warpPointer(const QPointF &globalPos)
 {
     Q_UNUSED(globalPos)
 }
 
 bool Platform::supportsQpaContext() const
 {
     if (Compositor *c = Compositor::self()) {
         return c->scene()->openGLPlatformInterfaceExtensions().contains(QByteArrayLiteral("EGL_KHR_surfaceless_context"));
     }
     return false;
 }
 
 EGLDisplay KWin::Platform::sceneEglDisplay() const
 {
     return m_eglDisplay;
 }
 
 void Platform::setSceneEglDisplay(EGLDisplay display)
 {
     m_eglDisplay = display;
 }
 
 QSize Platform::screenSize() const
 {
     return QSize();
 }
 
 QVector<QRect> Platform::screenGeometries() const
 {
     return QVector<QRect>({QRect(QPoint(0, 0), screenSize())});
 }
 
 QVector<qreal> Platform::screenScales() const
 {
     return QVector<qreal>({1});
 }
 
 bool Platform::requiresCompositing() const
 {
     return true;
 }
 
 bool Platform::compositingPossible() const
 {
     return true;
 }
 
 QString Platform::compositingNotPossibleReason() const
 {
     return QString();
 }
 
 bool Platform::openGLCompositingIsBroken() const
 {
     return false;
 }
 
 void Platform::createOpenGLSafePoint(OpenGLSafePoint safePoint)
 {
     Q_UNUSED(safePoint)
 }
 
 void Platform::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!input()) {
         callback(nullptr);
         return;
     }
     input()->startInteractiveWindowSelection(callback, cursorName);
 }
 
 void Platform::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
 {
     if (!input()) {
         callback(QPoint(-1, -1));
         return;
     }
     input()->startInteractivePositionSelection(callback);
 }
 
 void Platform::setupActionForGlobalAccel(QAction *action)
 {
     Q_UNUSED(action)
 }
 
 OverlayWindow *Platform::createOverlayWindow()
 {
     return nullptr;
 }
 
+static quint32 monotonicTime()
+{
+    timespec ts;
+
+    const int result = clock_gettime(CLOCK_MONOTONIC, &ts);
+    if (result)
+        qCWarning(KWIN_CORE, "Failed to query monotonic time: %s", strerror(errno));
+
+    return ts.tv_sec * 1000 + ts.tv_nsec / 1000000L;
+}
+
 void Platform::updateXTime()
 {
+    switch (kwinApp()->operationMode()) {
+    case Application::OperationModeX11:
+        kwinApp()->setX11Time(QX11Info::getTimestamp(), Application::TimestampUpdate::Always);
+        break;
+
+    case Application::OperationModeXwayland:
+        kwinApp()->setX11Time(monotonicTime(), Application::TimestampUpdate::Always);
+        break;
+
+    default:
+        // Do not update the current X11 time stamp if it's the Wayland only session.
+        break;
+    }
 }
 
 OutlineVisual *Platform::createOutline(Outline *outline)
 {
     if (Compositor::compositing()) {
        return new CompositedOutlineVisual(outline);
     }
     return nullptr;
 }
 
 Decoration::Renderer *Platform::createDecorationRenderer(Decoration::DecoratedClientImpl *client)
 {
     if (Compositor::self()->scene()) {
         return Compositor::self()->scene()->createDecorationRenderer(client);
     }
     return nullptr;
 }
 
 void Platform::invertScreen()
 {
     if (effects) {
         if (Effect *inverter = static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::ScreenInversion)) {
             qCDebug(KWIN_CORE) << "inverting screen using Effect plugin";
             QMetaObject::invokeMethod(inverter, "toggleScreenInversion", Qt::DirectConnection);
         }
     }
 }
 
 void Platform::createEffectsHandler(Compositor *compositor, Scene *scene)
 {
     new EffectsHandlerImpl(compositor, scene);
 }
 
 QString Platform::supportInformation() const
 {
     return QStringLiteral("Name: %1\n").arg(metaObject()->className());
 }
 
 }
diff --git a/platform.h b/platform.h
index d6da5c4e8..35d708fcb 100644
--- a/platform.h
+++ b/platform.h
@@ -1,571 +1,567 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_PLATFORM_H
 #define KWIN_PLATFORM_H
 #include <kwin_export.h>
 #include <kwinglobals.h>
 #include <epoxy/egl.h>
 #include <fixx11h.h>
 #include "fixqopengl.h"
 #include "input.h"
 
 #include <QImage>
 #include <QObject>
 
 #include <functional>
 
 class QAction;
 
 namespace KWayland {
     namespace Server {
         class OutputConfigurationInterface;
     }
 }
 
 namespace KWin
 {
 namespace ColorCorrect {
 class Manager;
 }
 
 class AbstractOutput;
 class Edge;
 class Compositor;
 class OverlayWindow;
 class OpenGLBackend;
 class Outline;
 class OutlineVisual;
 class QPainterBackend;
 class Scene;
 class Screens;
 class ScreenEdges;
 class Toplevel;
 class WaylandCursorTheme;
 
 namespace Decoration
 {
 class Renderer;
 class DecoratedClientImpl;
 }
 
 class KWIN_EXPORT Outputs : public QVector<AbstractOutput*>
 {
 public:
     Outputs(){};
     template <typename T>
     Outputs(const QVector<T> &other) {
         resize(other.size());
         std::copy(other.constBegin(), other.constEnd(), begin());
     }
 };
 
 class KWIN_EXPORT Platform : public QObject
 {
     Q_OBJECT
 public:
     ~Platform() override;
 
     virtual void init() = 0;
     virtual Screens *createScreens(QObject *parent = nullptr);
     virtual OpenGLBackend *createOpenGLBackend();
     virtual QPainterBackend *createQPainterBackend();
 
     /**
      * Informs the Platform that it is about to go down and shall do appropriate cleanup.
      * Child classes can override this function but must call the parent implementation in
      * the end.
      */
     virtual void prepareShutdown();
 
     /**
      * Allows the platform to create a platform specific screen edge.
      * The default implementation creates a Edge.
      */
     virtual Edge *createScreenEdge(ScreenEdges *parent);
     /**
      * Allows the platform to create a platform specific Cursor.
      * The default implementation creates an InputRedirectionCursor.
      */
     virtual void createPlatformCursor(QObject *parent = nullptr);
     virtual void warpPointer(const QPointF &globalPos);
     /**
      * Whether our Compositing EGL display allows a surface less context
      * so that a sharing context could be created.
      */
     virtual bool supportsQpaContext() const;
     /**
      * The EGLDisplay used by the compositing scene.
      */
     EGLDisplay sceneEglDisplay() const;
     void setSceneEglDisplay(EGLDisplay display);
     /**
      * The EGLContext used by the compositing scene.
      */
     virtual EGLContext sceneEglContext() const {
         return m_context;
     }
     /**
      * Sets the @p context used by the compositing scene.
      */
     void setSceneEglContext(EGLContext context) {
         m_context = context;
     }
     /**
      * The first (in case of multiple) EGLSurface used by the compositing scene.
      */
     EGLSurface sceneEglSurface() const {
         return m_surface;
     }
     /**
      * Sets the first @p surface used by the compositing scene.
      * @see sceneEglSurface
      */
     void setSceneEglSurface(EGLSurface surface) {
         m_surface = surface;
     }
 
     /**
      * The EglConfig used by the compositing scene.
      */
     EGLConfig sceneEglConfig() const {
         return m_eglConfig;
     }
     /**
      * Sets the @p config used by the compositing scene.
      * @see sceneEglConfig
      */
     void setSceneEglConfig(EGLConfig config) {
         m_eglConfig = config;
     }
 
     /**
      * Implementing subclasses should provide a size in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns an invalid size.
      */
     virtual QSize screenSize() const;
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns one QRect positioned at 0/0 with screenSize() as size.
      */
     virtual QVector<QRect> screenGeometries() const;
 
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns a screen with a scale of 1.
      */
     virtual QVector<qreal> screenScales() const;
     /**
      * Implement this method to receive configuration change requests through KWayland's
      * OutputManagement interface.
      *
      * Base implementation warns that the current backend does not implement this
      * functionality.
      */
     void requestOutputsChange(KWayland::Server::OutputConfigurationInterface *config);
 
     /**
      * Whether the Platform requires compositing for rendering.
      * Default implementation returns @c true. If the implementing Platform allows to be used
      * without compositing (e.g. rendering is done by the windowing system), re-implement this method.
      */
     virtual bool requiresCompositing() const;
     /**
      * Whether Compositing is possible in the Platform.
      * Returning @c false in this method makes only sense if requiresCompositing returns @c false.
      *
      * The default implementation returns @c true.
      * @see requiresCompositing
      */
     virtual bool compositingPossible() const;
     /**
      * Returns a user facing text explaining why compositing is not possible in case
      * compositingPossible returns @c false.
      *
      * The default implementation returns an empty string.
      * @see compositingPossible
      */
     virtual QString compositingNotPossibleReason() const;
     /**
      * Whether OpenGL compositing is broken.
      * The Platform can implement this method if it is able to detect whether OpenGL compositing
      * broke (e.g. triggered a crash in a previous run).
      *
      * Default implementation returns @c false.
      * @see createOpenGLSafePoint
      */
     virtual bool openGLCompositingIsBroken() const;
     enum class OpenGLSafePoint {
         PreInit,
         PostInit,
         PreFrame,
         PostFrame,
         PostLastGuardedFrame
     };
     /**
      * This method is invoked before and after creating the OpenGL rendering Scene.
      * An implementing Platform can use it to detect crashes triggered by the OpenGL implementation.
      * This can be used for openGLCompositingIsBroken.
      *
      * The default implementation does nothing.
      * @see openGLCompositingIsBroken.
      */
     virtual void createOpenGLSafePoint(OpenGLSafePoint safePoint);
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected Toplevel as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor unless
      * @p cursorName is provided. The argument @p cursorName is a QByteArray instead of Qt::CursorShape
      * to support the "pirate" cursor for kill window which is not wrapped by Qt::CursorShape.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @param cursorName The optional name of the cursor shape to use, default is crosshair
      */
     virtual void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName = QByteArray());
 
     /**
      * Starts an interactive position selection process.
      *
      * Once the user selected a position on the screen the @p callback is invoked with
      * the selected point as argument. In case the user cancels the interactive position selection
      * or selecting a position is currently not possible (e.g. screen locked) the @p callback
      * is invoked with a point at @c -1 as x and y argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive position selection ends
      */
     virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
 
     /**
      * Platform specific preparation for an @p action which is used for KGlobalAccel.
      *
      * A platform might need to do preparation for an @p action before
      * it can be used with KGlobalAccel.
      *
      * Code using KGlobalAccel should invoke this method for the @p action
      * prior to setting up any shortcuts and connections.
      *
      * The default implementation does nothing.
      *
      * @param action The action which will be used with KGlobalAccel.
      * @since 5.10
      */
     virtual void setupActionForGlobalAccel(QAction *action);
 
     bool usesSoftwareCursor() const {
         return m_softWareCursor;
     }
 
     /**
      * Returns a PlatformCursorImage. By default this is created by softwareCursor and
      * softwareCursorHotspot. An implementing subclass can use this to provide a better
      * suited PlatformCursorImage.
      *
      * @see softwareCursor
      * @see softwareCursorHotspot
      * @since 5.9
      */
     virtual PlatformCursorImage cursorImage() const;
 
     /**
      * The Platform cursor image should be hidden.
      * @see showCursor
      * @see doHideCursor
      * @see isCursorHidden
      * @since 5.9
      */
     void hideCursor();
 
     /**
      * The Platform cursor image should be shown again.
      * @see hideCursor
      * @see doShowCursor
      * @see isCursorHidden
      * @since 5.9
      */
     void showCursor();
 
     /**
      * Whether the cursor is currently hidden.
      * @see showCursor
      * @see hideCursor
      * @since 5.9
      */
     bool isCursorHidden() const {
         return m_hideCursorCounter > 0;
     }
     bool isReady() const {
         return m_ready;
     }
     void setInitialWindowSize(const QSize &size) {
         m_initialWindowSize = size;
     }
     void setDeviceIdentifier(const QByteArray &identifier) {
         m_deviceIdentifier = identifier;
     }
     bool supportsPointerWarping() const {
         return m_pointerWarping;
     }
     bool areOutputsEnabled() const {
         return m_outputsEnabled;
     }
     void setOutputsEnabled(bool enabled) {
         m_outputsEnabled = enabled;
     }
     int initialOutputCount() const {
         return m_initialOutputCount;
     }
     void setInitialOutputCount(int count) {
         m_initialOutputCount = count;
     }
     qreal initialOutputScale() const {
         return m_initialOutputScale;
     }
     void setInitialOutputScale(qreal scale) {
         m_initialOutputScale = scale;
     }
 
     /**
      * Creates the OverlayWindow required for X11 based compositors.
      * Default implementation returns @c nullptr.
      */
     virtual OverlayWindow *createOverlayWindow();
 
     /**
-     * Allows a platform to update the X11 timestamp.
-     * Mostly for the X11 standalone platform to interact with QX11Info.
-     *
-     * Default implementation does nothing. This means code relying on the X timestamp being up to date,
-     * might not be working. E.g. synced X11 window resizing
+     * Queries the current X11 time stamp of the X server.
      */
-    virtual void updateXTime();
+    void updateXTime();
 
     /**
      * Creates the OutlineVisual for the given @p outline.
      * Default implementation creates an OutlineVisual suited for composited usage.
      */
     virtual OutlineVisual *createOutline(Outline *outline);
 
     /**
      * Creates the Decoration::Renderer for the given @p client.
      *
      * The default implementation creates a Renderer suited for the Compositor, @c nullptr if there is no Compositor.
      */
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *client);
 
     /**
      * Platform specific way to invert the screen.
      * Default implementation invokes the invert effect
      */
     virtual void invertScreen();
 
     /**
      * Default implementation creates an EffectsHandlerImp;
      */
     virtual void createEffectsHandler(Compositor *compositor, Scene *scene);
 
     /**
      * The CompositingTypes supported by the Platform.
      * The first item should be the most preferred one.
      * @since 5.11
      */
     virtual QVector<CompositingType> supportedCompositors() const = 0;
 
     /**
      * Whether gamma control is supported by the backend.
      * @since 5.12
      */
     bool supportsGammaControl() const {
         return m_supportsGammaControl;
     }
 
     ColorCorrect::Manager *colorCorrectManager() {
         return m_colorCorrect;
     }
 
     // outputs with connections (org_kde_kwin_outputdevice)
     virtual Outputs outputs() const {
         return Outputs();
     }
     // actively compositing outputs (wl_output)
     virtual Outputs enabledOutputs() const {
         return Outputs();
     }
     AbstractOutput *findOutput(const QByteArray &uuid);
 
     /**
      * A string of information to include in kwin debug output
      * It should not be translated.
      *
      * The base implementation prints the name.
      * @since 5.12
      */
     virtual QString supportInformation() const;
 
     /**
      * The compositor plugin which got selected from @ref supportedCompositors.
      * Prior to selecting a compositor this returns @c NoCompositing.
      *
      * This method allows the platforms to limit the offerings in @ref supportedCompositors
      * in case they do not support runtime compositor switching
      */
     CompositingType selectedCompositor() const
     {
         return m_selectedCompositor;
     }
     /**
      * Used by Compositor to set the used compositor.
      */
     void setSelectedCompositor(CompositingType type)
     {
         m_selectedCompositor = type;
     }
 
 public Q_SLOTS:
     void pointerMotion(const QPointF &position, quint32 time);
     void pointerButtonPressed(quint32 button, quint32 time);
     void pointerButtonReleased(quint32 button, quint32 time);
     void pointerAxisHorizontal(qreal delta, quint32 time, qint32 discreteDelta = 0,
         InputRedirection::PointerAxisSource source = InputRedirection::PointerAxisSourceUnknown);
     void pointerAxisVertical(qreal delta, quint32 time, qint32 discreteDelta = 0,
         InputRedirection::PointerAxisSource source = InputRedirection::PointerAxisSourceUnknown);
     void keyboardKeyPressed(quint32 key, quint32 time);
     void keyboardKeyReleased(quint32 key, quint32 time);
     void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     void keymapChange(int fd, uint32_t size);
     void touchDown(qint32 id, const QPointF &pos, quint32 time);
     void touchUp(qint32 id, quint32 time);
     void touchMotion(qint32 id, const QPointF &pos, quint32 time);
     void touchCancel();
     void touchFrame();
 
     void processSwipeGestureBegin(int fingerCount, quint32 time);
     void processSwipeGestureUpdate(const QSizeF &delta, quint32 time);
     void processSwipeGestureEnd(quint32 time);
     void processSwipeGestureCancelled(quint32 time);
     void processPinchGestureBegin(int fingerCount, quint32 time);
     void processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     void processPinchGestureEnd(quint32 time);
     void processPinchGestureCancelled(quint32 time);
 
     void cursorRendered(const QRect &geometry);
 
 Q_SIGNALS:
     void screensQueried();
     void initFailed();
     void readyChanged(bool);
     /**
      * Emitted by backends using a one screen (nested window) approach and when the size of that changes.
      */
     void screenSizeChanged();
 
 protected:
     explicit Platform(QObject *parent = nullptr);
     void setSoftWareCursor(bool set);
     void repaint(const QRect &rect);
     void setReady(bool ready);
     QSize initialWindowSize() const {
         return m_initialWindowSize;
     }
     QByteArray deviceIdentifier() const {
         return m_deviceIdentifier;
     }
     void setSupportsPointerWarping(bool set) {
         m_pointerWarping = set;
     }
     void setSupportsGammaControl(bool set) {
         m_supportsGammaControl = set;
     }
 
     /**
      * Whether the backend is supposed to change the configuration of outputs.
      */
     void supportsOutputChanges() {
         m_supportsOutputChanges = true;
     }
 
     /**
      * Actual platform specific way to hide the cursor.
      * Sub-classes need to implement if they support hiding the cursor.
      *
      * This method is invoked by hideCursor if the cursor needs to be hidden.
      * The default implementation does nothing.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      */
     virtual void doHideCursor();
     /**
      * Actual platform specific way to show the cursor.
      * Sub-classes need to implement if they support showing the cursor.
      *
      * This method is invoked by showCursor if the cursor needs to be shown again.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      */
     virtual void doShowCursor();
 
 private:
     void triggerCursorRepaint();
     bool m_softWareCursor = false;
     struct {
         QRect lastRenderedGeometry;
     } m_cursor;
     bool m_ready = false;
     QSize m_initialWindowSize;
     QByteArray m_deviceIdentifier;
     bool m_pointerWarping = false;
     bool m_outputsEnabled = true;
     int m_initialOutputCount = 1;
     qreal m_initialOutputScale = 1;
     EGLDisplay m_eglDisplay;
     EGLConfig m_eglConfig = nullptr;
     EGLContext m_context = EGL_NO_CONTEXT;
     EGLSurface m_surface = EGL_NO_SURFACE;
     int m_hideCursorCounter = 0;
     ColorCorrect::Manager *m_colorCorrect = nullptr;
     bool m_supportsGammaControl = false;
     bool m_supportsOutputChanges = false;
     CompositingType m_selectedCompositor = NoCompositing;
 };
 
 }
 
 Q_DECLARE_INTERFACE(KWin::Platform, "org.kde.kwin.Platform")
 
 #endif
diff --git a/plugins/platforms/x11/standalone/x11_platform.cpp b/plugins/platforms/x11/standalone/x11_platform.cpp
index 92a833791..7310d8df2 100644
--- a/plugins/platforms/x11/standalone/x11_platform.cpp
+++ b/plugins/platforms/x11/standalone/x11_platform.cpp
@@ -1,561 +1,545 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "x11_platform.h"
 #include "x11cursor.h"
 #include "edge.h"
 #include "sync_filter.h"
 #include "windowselector.h"
 #include <config-kwin.h>
 #include <kwinconfig.h>
 #if HAVE_EPOXY_GLX
 #include "glxbackend.h"
 #endif
 #if HAVE_X11_XINPUT
 #include "xinputintegration.h"
 #endif
 #include "abstract_client.h"
 #include "effects_x11.h"
 #include "eglonxbackend.h"
 #include "keyboard_input.h"
 #include "logging.h"
 #include "screens_xrandr.h"
 #include "screenedges_filter.h"
 #include "options.h"
 #include "overlaywindow_x11.h"
 #include "non_composited_outline.h"
 #include "workspace.h"
 #include "x11_decoration_renderer.h"
 #include "x11_output.h"
 #include "xcbutils.h"
 
 #include <kwinxrenderutils.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KCrash>
 
 #include <QThread>
 #include <QOpenGLContext>
 #include <QX11Info>
 
 namespace KWin
 {
 
 X11StandalonePlatform::X11StandalonePlatform(QObject *parent)
     : Platform(parent)
     , m_x11Display(QX11Info::display())
 {
 #if HAVE_X11_XINPUT
     if (!qEnvironmentVariableIsSet("KWIN_NO_XI2")) {
         m_xinputIntegration = new XInputIntegration(m_x11Display, this);
         m_xinputIntegration->init();
         if (!m_xinputIntegration->hasXinput()) {
             delete m_xinputIntegration;
             m_xinputIntegration = nullptr;
         } else {
             connect(kwinApp(), &Application::workspaceCreated, m_xinputIntegration, &XInputIntegration::startListening);
         }
     }
 #endif
     connect(kwinApp(), &Application::workspaceCreated, this,
         [this] {
             if (Xcb::Extensions::self()->isSyncAvailable()) {
                 m_syncFilter = std::make_unique<SyncFilter>();
             }
         }
     );
 
     setSupportsGammaControl(true);
 }
 
 X11StandalonePlatform::~X11StandalonePlatform()
 {
     if (m_openGLFreezeProtectionThread) {
         m_openGLFreezeProtectionThread->quit();
         m_openGLFreezeProtectionThread->wait();
         delete m_openGLFreezeProtectionThread;
     }
     if (isReady()) {
         XRenderUtils::cleanup();
     }
 }
 
 void X11StandalonePlatform::init()
 {
     if (!QX11Info::isPlatformX11()) {
         emit initFailed();
         return;
     }
     XRenderUtils::init(kwinApp()->x11Connection(), kwinApp()->x11RootWindow());
     setReady(true);
     emit screensQueried();
 }
 
 Screens *X11StandalonePlatform::createScreens(QObject *parent)
 {
     return new XRandRScreens(this, parent);
 }
 
 OpenGLBackend *X11StandalonePlatform::createOpenGLBackend()
 {
     switch (options->glPlatformInterface()) {
 #if HAVE_EPOXY_GLX
     case GlxPlatformInterface:
         if (hasGlx()) {
             return new GlxBackend(m_x11Display);
         } else {
             qCWarning(KWIN_X11STANDALONE) << "Glx not available, trying EGL instead.";
             // no break, needs fall-through
             Q_FALLTHROUGH();
         }
 #endif
     case EglPlatformInterface:
         return new EglOnXBackend(m_x11Display);
     default:
         // no backend available
         return nullptr;
     }
 }
 
 Edge *X11StandalonePlatform::createScreenEdge(ScreenEdges *edges)
 {
     if (m_screenEdgesFilter.isNull()) {
         m_screenEdgesFilter.reset(new ScreenEdgesFilter);
     }
     return new WindowBasedEdge(edges);
 }
 
 void X11StandalonePlatform::createPlatformCursor(QObject *parent)
 {
     auto c = new X11Cursor(parent, m_xinputIntegration != nullptr);
 #if HAVE_X11_XINPUT
     if (m_xinputIntegration) {
         m_xinputIntegration->setCursor(c);
         // we know we have xkb already
         auto xkb = input()->keyboard()->xkb();
         xkb->setConfig(kwinApp()->kxkbConfig());
         xkb->reconfigure();
     }
 #endif
 }
 
 bool X11StandalonePlatform::requiresCompositing() const
 {
     return false;
 }
 
 bool X11StandalonePlatform::openGLCompositingIsBroken() const
 {
     const QString unsafeKey(QLatin1String("OpenGLIsUnsafe") + (kwinApp()->isX11MultiHead() ? QString::number(kwinApp()->x11ScreenNumber()) : QString()));
     return KConfigGroup(kwinApp()->config(), "Compositing").readEntry(unsafeKey, false);
 }
 
 QString X11StandalonePlatform::compositingNotPossibleReason() const
 {
     // first off, check whether we figured that we'll crash on detection because of a buggy driver
     KConfigGroup gl_workaround_group(kwinApp()->config(), "Compositing");
     const QString unsafeKey(QLatin1String("OpenGLIsUnsafe") + (kwinApp()->isX11MultiHead() ? QString::number(kwinApp()->x11ScreenNumber()) : QString()));
     if (gl_workaround_group.readEntry("Backend", "OpenGL") == QLatin1String("OpenGL") &&
         gl_workaround_group.readEntry(unsafeKey, false))
         return i18n("<b>OpenGL compositing (the default) has crashed KWin in the past.</b><br>"
                     "This was most likely due to a driver bug."
                     "<p>If you think that you have meanwhile upgraded to a stable driver,<br>"
                     "you can reset this protection but <b>be aware that this might result in an immediate crash!</b></p>"
                     "<p>Alternatively, you might want to use the XRender backend instead.</p>");
 
     if (!Xcb::Extensions::self()->isCompositeAvailable() || !Xcb::Extensions::self()->isDamageAvailable()) {
         return i18n("Required X extensions (XComposite and XDamage) are not available.");
     }
 #if !defined( KWIN_HAVE_XRENDER_COMPOSITING )
     if (!hasGlx())
         return i18n("GLX/OpenGL are not available and only OpenGL support is compiled.");
 #else
     if (!(hasGlx()
             || (Xcb::Extensions::self()->isRenderAvailable() && Xcb::Extensions::self()->isFixesAvailable()))) {
         return i18n("GLX/OpenGL and XRender/XFixes are not available.");
     }
 #endif
     return QString();
 }
 
 bool X11StandalonePlatform::compositingPossible() const
 {
     // first off, check whether we figured that we'll crash on detection because of a buggy driver
     KConfigGroup gl_workaround_group(kwinApp()->config(), "Compositing");
     const QString unsafeKey(QLatin1String("OpenGLIsUnsafe") + (kwinApp()->isX11MultiHead() ? QString::number(kwinApp()->x11ScreenNumber()) : QString()));
     if (gl_workaround_group.readEntry("Backend", "OpenGL") == QLatin1String("OpenGL") &&
         gl_workaround_group.readEntry(unsafeKey, false))
         return false;
 
 
     if (!Xcb::Extensions::self()->isCompositeAvailable()) {
         qCDebug(KWIN_CORE) << "No composite extension available";
         return false;
     }
     if (!Xcb::Extensions::self()->isDamageAvailable()) {
         qCDebug(KWIN_CORE) << "No damage extension available";
         return false;
     }
     if (hasGlx())
         return true;
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (Xcb::Extensions::self()->isRenderAvailable() && Xcb::Extensions::self()->isFixesAvailable())
         return true;
 #endif
     if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES) {
         return true;
     } else if (qstrcmp(qgetenv("KWIN_COMPOSE"), "O2ES") == 0) {
         return true;
     }
     qCDebug(KWIN_CORE) << "No OpenGL or XRender/XFixes support";
     return false;
 }
 
 bool X11StandalonePlatform::hasGlx()
 {
     return Xcb::Extensions::self()->hasGlx();
 }
 
 void X11StandalonePlatform::createOpenGLSafePoint(OpenGLSafePoint safePoint)
 {
     const QString unsafeKey(QLatin1String("OpenGLIsUnsafe") + (kwinApp()->isX11MultiHead() ? QString::number(kwinApp()->x11ScreenNumber()) : QString()));
     auto group = KConfigGroup(kwinApp()->config(), "Compositing");
     switch (safePoint) {
     case OpenGLSafePoint::PreInit:
         group.writeEntry(unsafeKey, true);
         group.sync();
         // Deliberately continue with PreFrame
         Q_FALLTHROUGH();
     case OpenGLSafePoint::PreFrame:
         if (m_openGLFreezeProtectionThread == nullptr) {
             Q_ASSERT(m_openGLFreezeProtection == nullptr);
             m_openGLFreezeProtectionThread = new QThread(this);
             m_openGLFreezeProtectionThread->setObjectName("FreezeDetector");
             m_openGLFreezeProtectionThread->start();
             m_openGLFreezeProtection = new QTimer;
             m_openGLFreezeProtection->setInterval(15000);
             m_openGLFreezeProtection->setSingleShot(true);
             m_openGLFreezeProtection->start();
             const QString configName = kwinApp()->config()->name();
             m_openGLFreezeProtection->moveToThread(m_openGLFreezeProtectionThread);
             connect(m_openGLFreezeProtection, &QTimer::timeout, m_openGLFreezeProtection,
                 [configName] {
                     const QString unsafeKey(QLatin1String("OpenGLIsUnsafe") + (kwinApp()->isX11MultiHead() ? QString::number(kwinApp()->x11ScreenNumber()) : QString()));
                     auto group = KConfigGroup(KSharedConfig::openConfig(configName), "Compositing");
                     group.writeEntry(unsafeKey, true);
                     group.sync();
                     KCrash::setDrKonqiEnabled(false);
                     qFatal("Freeze in OpenGL initialization detected");
                 }, Qt::DirectConnection);
         } else {
             Q_ASSERT(m_openGLFreezeProtection);
             QMetaObject::invokeMethod(m_openGLFreezeProtection, "start", Qt::QueuedConnection);
         }
         break;
     case OpenGLSafePoint::PostInit:
         group.writeEntry(unsafeKey, false);
         group.sync();
         // Deliberately continue with PostFrame
         Q_FALLTHROUGH();
     case OpenGLSafePoint::PostFrame:
         QMetaObject::invokeMethod(m_openGLFreezeProtection, "stop", Qt::QueuedConnection);
         break;
     case OpenGLSafePoint::PostLastGuardedFrame:
         m_openGLFreezeProtection->deleteLater();
         m_openGLFreezeProtection = nullptr;
         m_openGLFreezeProtectionThread->quit();
         m_openGLFreezeProtectionThread->wait();
         delete m_openGLFreezeProtectionThread;
         m_openGLFreezeProtectionThread = nullptr;
         break;
     }
 }
 
 PlatformCursorImage X11StandalonePlatform::cursorImage() const
 {
     auto c = kwinApp()->x11Connection();
     QScopedPointer<xcb_xfixes_get_cursor_image_reply_t, QScopedPointerPodDeleter> cursor(
         xcb_xfixes_get_cursor_image_reply(c,
                                           xcb_xfixes_get_cursor_image_unchecked(c),
                                           nullptr));
     if (cursor.isNull()) {
         return PlatformCursorImage();
     }
 
     QImage qcursorimg((uchar *) xcb_xfixes_get_cursor_image_cursor_image(cursor.data()), cursor->width, cursor->height,
                       QImage::Format_ARGB32_Premultiplied);
     // deep copy of image as the data is going to be freed
     return PlatformCursorImage(qcursorimg.copy(), QPoint(cursor->xhot, cursor->yhot));
 }
 
 void X11StandalonePlatform::doHideCursor()
 {
     xcb_xfixes_hide_cursor(kwinApp()->x11Connection(), kwinApp()->x11RootWindow());
 }
 
 void X11StandalonePlatform::doShowCursor()
 {
     xcb_xfixes_show_cursor(kwinApp()->x11Connection(), kwinApp()->x11RootWindow());
 }
 
 void X11StandalonePlatform::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (m_windowSelector.isNull()) {
         m_windowSelector.reset(new WindowSelector);
     }
     m_windowSelector->start(callback, cursorName);
 }
 
 void X11StandalonePlatform::startInteractivePositionSelection(std::function<void (const QPoint &)> callback)
 {
     if (m_windowSelector.isNull()) {
         m_windowSelector.reset(new WindowSelector);
     }
     m_windowSelector->start(callback);
 }
 
 void X11StandalonePlatform::setupActionForGlobalAccel(QAction *action)
 {
     connect(action, &QAction::triggered, kwinApp(), [action] {
         QVariant timestamp = action->property("org.kde.kglobalaccel.activationTimestamp");
         bool ok = false;
         const quint32 t = timestamp.toULongLong(&ok);
         if (ok) {
             kwinApp()->setX11Time(t);
         }
     });
 }
 
 OverlayWindow *X11StandalonePlatform::createOverlayWindow()
 {
     return new OverlayWindowX11();
 }
 
-/*
- Updates xTime(). This used to simply fetch current timestamp from the server,
- but that can cause xTime() to be newer than timestamp of events that are
- still in our events queue, thus e.g. making XSetInputFocus() caused by such
- event to be ignored. Therefore events queue is searched for first
- event with timestamp, and extra PropertyNotify is generated in order to make
- sure such event is found.
-*/
-void X11StandalonePlatform::updateXTime()
-{
-    // NOTE: QX11Info::getTimestamp does not yet search the event queue as the old
-    // solution did. This means there might be regressions currently. See the
-    // documentation above on how it should be done properly.
-    kwinApp()->setX11Time(QX11Info::getTimestamp(), Application::TimestampUpdate::Always);
-}
-
 OutlineVisual *X11StandalonePlatform::createOutline(Outline *outline)
 {
     // first try composited Outline
     auto ret = Platform::createOutline(outline);
     if (!ret) {
         ret = new NonCompositedOutlineVisual(outline);
     }
     return ret;
 }
 
 Decoration::Renderer *X11StandalonePlatform::createDecorationRenderer(Decoration::DecoratedClientImpl *client)
 {
     auto renderer = Platform::createDecorationRenderer(client);
     if (!renderer) {
         renderer = new Decoration::X11Renderer(client);
     }
     return renderer;
 }
 
 void X11StandalonePlatform::invertScreen()
 {
     using namespace Xcb::RandR;
     bool succeeded = false;
 
     if (Xcb::Extensions::self()->isRandrAvailable()) {
         const auto active_client = workspace()->activeClient();
         ScreenResources res((active_client && active_client->window() != XCB_WINDOW_NONE) ? active_client->window() : rootWindow());
 
         if (!res.isNull()) {
             for (int j = 0; j < res->num_crtcs; ++j) {
                 auto crtc = res.crtcs()[j];
                 CrtcGamma gamma(crtc);
                 if (gamma.isNull()) {
                     continue;
                 }
                 if (gamma->size) {
                     qCDebug(KWIN_CORE) << "inverting screen using xcb_randr_set_crtc_gamma";
                     const int half = gamma->size / 2 + 1;
 
                     uint16_t *red = gamma.red();
                     uint16_t *green = gamma.green();
                     uint16_t *blue = gamma.blue();
                     for (int i = 0; i < half; ++i) {
                         auto invert = [&gamma, i](uint16_t *ramp) {
                             qSwap(ramp[i], ramp[gamma->size - 1 - i]);
                         };
                         invert(red);
                         invert(green);
                         invert(blue);
                     }
                     xcb_randr_set_crtc_gamma(connection(), crtc, gamma->size, red, green, blue);
                     succeeded = true;
                 }
             }
         }
     }
     if (!succeeded) {
         Platform::invertScreen();
     }
 }
 
 void X11StandalonePlatform::createEffectsHandler(Compositor *compositor, Scene *scene)
 {
     new EffectsHandlerImplX11(compositor, scene);
 }
 
 QVector<CompositingType> X11StandalonePlatform::supportedCompositors() const
 {
     QVector<CompositingType> compositors;
 #if HAVE_EPOXY_GLX
     compositors << OpenGLCompositing;
 #endif
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     compositors << XRenderCompositing;
 #endif
     compositors << NoCompositing;
     return compositors;
 }
 
 void X11StandalonePlatform::initOutputs()
 {
     doUpdateOutputs<Xcb::RandR::ScreenResources>();
 }
 
 void X11StandalonePlatform::updateOutputs()
 {
     doUpdateOutputs<Xcb::RandR::CurrentResources>();
 }
 
 template <typename T>
 void X11StandalonePlatform::doUpdateOutputs()
 {
     auto fallback = [this]() {
         auto *o = new X11Output(this);
         o->setGammaRampSize(0);
         o->setRefreshRate(-1.0f);
         o->setName(QStringLiteral("Xinerama"));
         m_outputs << o;
     };
 
     // TODO: instead of resetting all outputs, check if new output is added/removed
     //       or still available and leave still available outputs in m_outputs
     //       untouched (like in DRM backend)
     qDeleteAll(m_outputs);
     m_outputs.clear();
 
     if (!Xcb::Extensions::self()->isRandrAvailable()) {
         fallback();
         return;
     }
     T resources(rootWindow());
     if (resources.isNull()) {
         fallback();
         return;
     }
     xcb_randr_crtc_t *crtcs = resources.crtcs();
     xcb_randr_mode_info_t *modes = resources.modes();
 
     QVector<Xcb::RandR::CrtcInfo> infos(resources->num_crtcs);
     for (int i = 0; i < resources->num_crtcs; ++i) {
         infos[i] = Xcb::RandR::CrtcInfo(crtcs[i], resources->config_timestamp);
     }
 
     for (int i = 0; i < resources->num_crtcs; ++i) {
         Xcb::RandR::CrtcInfo info(infos.at(i));
 
         xcb_randr_output_t *outputs = info.outputs();
         QVector<Xcb::RandR::OutputInfo> outputInfos(outputs ? resources->num_outputs : 0);
         if (outputs) {
             for (int i = 0; i < resources->num_outputs; ++i) {
                 outputInfos[i] = Xcb::RandR::OutputInfo(outputs[i], resources->config_timestamp);
             }
         }
 
         float refreshRate = -1.0f;
         for (int j = 0; j < resources->num_modes; ++j) {
             if (info->mode == modes[j].id) {
                 if (modes[j].htotal != 0 && modes[j].vtotal != 0) { // BUG 313996
                     // refresh rate calculation - WTF was wikipedia 1998 when I needed it?
                     int dotclock = modes[j].dot_clock,
                           vtotal = modes[j].vtotal;
                     if (modes[j].mode_flags & XCB_RANDR_MODE_FLAG_INTERLACE)
                         dotclock *= 2;
                     if (modes[j].mode_flags & XCB_RANDR_MODE_FLAG_DOUBLE_SCAN)
                         vtotal *= 2;
                     refreshRate = dotclock/float(modes[j].htotal*vtotal);
                 }
                 break; // found mode
             }
         }
 
         const QRect geo = info.rect();
         if (geo.isValid()) {
             xcb_randr_crtc_t crtc = crtcs[i];
 
             // TODO: Perhaps the output has to save the inherited gamma ramp and
             // restore it during tear down. Currently neither standalone x11 nor
             // drm platform do this.
             Xcb::RandR::CrtcGamma gamma(crtc);
 
             auto *o = new X11Output(this);
             o->setCrtc(crtc);
             o->setGammaRampSize(gamma.isNull() ? 0 : gamma->size);
             o->setGeometry(geo);
             o->setRefreshRate(refreshRate * 1000);
 
             QString name;
             for (int j = 0; j < info->num_outputs; ++j) {
                 Xcb::RandR::OutputInfo outputInfo(outputInfos.at(j));
                 if (crtc == outputInfo->crtc) {
                     name = outputInfo.name();
                     break;
                 }
             }
             o->setName(name);
             m_outputs << o;
         }
     }
 
     if (m_outputs.isEmpty()) {
         fallback();
     }
 }
 
 Outputs X11StandalonePlatform::outputs() const
 {
     return m_outputs;
 }
 
 Outputs X11StandalonePlatform::enabledOutputs() const
 {
     return m_outputs;
 }
 
 }
diff --git a/plugins/platforms/x11/standalone/x11_platform.h b/plugins/platforms/x11/standalone/x11_platform.h
index ac6fff0ac..78a12704b 100644
--- a/plugins/platforms/x11/standalone/x11_platform.h
+++ b/plugins/platforms/x11/standalone/x11_platform.h
@@ -1,113 +1,111 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_X11_PLATFORM_H
 #define KWIN_X11_PLATFORM_H
 #include "platform.h"
 
 #include <kwin_export.h>
 
 #include <QObject>
 
 #include <memory>
 
 namespace KWin
 {
 class SyncFilter;
 class XInputIntegration;
 class WindowSelector;
 class X11EventFilter;
 class X11Output;
 
 class KWIN_EXPORT X11StandalonePlatform : public Platform
 {
     Q_OBJECT
     Q_INTERFACES(KWin::Platform)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Platform" FILE "x11.json")
 public:
     X11StandalonePlatform(QObject *parent = nullptr);
     ~X11StandalonePlatform() override;
     void init() override;
 
     Screens *createScreens(QObject *parent = nullptr) override;
     OpenGLBackend *createOpenGLBackend() override;
     Edge *createScreenEdge(ScreenEdges *parent) override;
     void createPlatformCursor(QObject *parent = nullptr) override;
     bool requiresCompositing() const override;
     bool compositingPossible() const override;
     QString compositingNotPossibleReason() const override;
     bool openGLCompositingIsBroken() const override;
     void createOpenGLSafePoint(OpenGLSafePoint safePoint) override;
     void startInteractiveWindowSelection(std::function<void (KWin::Toplevel *)> callback, const QByteArray &cursorName = QByteArray()) override;
     void startInteractivePositionSelection(std::function<void (const QPoint &)> callback) override;
 
     PlatformCursorImage cursorImage() const override;
 
     void setupActionForGlobalAccel(QAction *action) override;
 
     OverlayWindow *createOverlayWindow() override;
-
-    void updateXTime() override;
     OutlineVisual *createOutline(Outline *outline) override;
     Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *client) override;
 
     void invertScreen() override;
 
     void createEffectsHandler(Compositor *compositor, Scene *scene) override;
     QVector<CompositingType> supportedCompositors() const override;
 
     void initOutputs();
     void updateOutputs();
 
     Outputs outputs() const override;
     Outputs enabledOutputs() const override;
 
 protected:
     void doHideCursor() override;
     void doShowCursor() override;
 
 private:
     /**
      * Tests whether GLX is supported and returns @c true
      * in case KWin is compiled with OpenGL support and GLX
      * is available.
      *
      * If KWin is compiled with OpenGL ES or without OpenGL at
      * all, @c false is returned.
      * @returns @c true if GLX is available, @c false otherwise and if not build with OpenGL support.
      */
     static bool hasGlx();
 
     template <typename T>
     void doUpdateOutputs();
 
     XInputIntegration *m_xinputIntegration = nullptr;
     QThread *m_openGLFreezeProtectionThread = nullptr;
     QTimer *m_openGLFreezeProtection = nullptr;
     Display *m_x11Display;
     QScopedPointer<WindowSelector> m_windowSelector;
     QScopedPointer<X11EventFilter> m_screenEdgesFilter;
     std::unique_ptr<SyncFilter> m_syncFilter;
 
     QVector<X11Output*> m_outputs;
 };
 
 }
 
 #endif