diff --git a/composite.cpp b/composite.cpp
index a95382fb6..234a21431 100644
--- a/composite.cpp
+++ b/composite.cpp
@@ -1,1050 +1,1048 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@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 "composite.h"
 
 #include "dbusinterface.h"
 #include "x11client.h"
 #include "decorations/decoratedclient.h"
 #include "deleted.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "overlaywindow.h"
 #include "platform.h"
 #include "scene.h"
 #include "screens.h"
 #include "shadow.h"
 #include "xdgshellclient.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "utils.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
 #include <kwingltexture.h>
 
 #include <KWayland/Server/surface_interface.h>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginLoader>
 #include <KPluginMetaData>
 #include <KNotification>
 #include <KSelectionOwner>
 
 #include <QDateTime>
 #include <QFutureWatcher>
 #include <QMenu>
 #include <QOpenGLContext>
 #include <QQuickWindow>
 #include <QtConcurrentRun>
 #include <QTextStream>
 #include <QTimerEvent>
 
 #include <xcb/composite.h>
 #include <xcb/damage.h>
 
 #include <cstdio>
 
 Q_DECLARE_METATYPE(KWin::X11Compositor::SuspendReason)
 
 namespace KWin
 {
 
 // See main.cpp:
 extern int screen_number;
 
 extern bool is_multihead;
 extern int currentRefreshRate();
 
 Compositor *Compositor::s_compositor = nullptr;
 Compositor *Compositor::self()
 {
     return s_compositor;
 }
 
 WaylandCompositor *WaylandCompositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new WaylandCompositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 X11Compositor *X11Compositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new X11Compositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 
 class CompositorSelectionOwner : public KSelectionOwner
 {
     Q_OBJECT
 public:
     CompositorSelectionOwner(const char *selection)
         : KSelectionOwner(selection, connection(), rootWindow())
         , m_owning(false)
     {
         connect (this, &CompositorSelectionOwner::lostOwnership,
                  this, [this]() { m_owning = false; });
     }
     bool owning() const {
         return m_owning;
     }
     void setOwning(bool own) {
         m_owning = own;
     }
 private:
     bool m_owning;
 };
 
 static inline qint64 milliToNano(int milli) { return qint64(milli) * 1000 * 1000; }
 static inline qint64 nanoToMilli(int nano) { return nano / (1000*1000); }
 
 Compositor::Compositor(QObject* workspace)
     : QObject(workspace)
     , m_state(State::Off)
     , m_selectionOwner(nullptr)
     , vBlankInterval(0)
     , fpsInterval(0)
     , m_timeSinceLastVBlank(0)
     , m_scene(nullptr)
     , m_bufferSwapPending(false)
     , m_composeAtSwapCompletion(false)
 {
     connect(options, &Options::configChanged, this, &Compositor::configChanged);
     connect(options, &Options::animationSpeedChanged, this, &Compositor::configChanged);
 
     m_monotonicClock.start();
 
     // 2 sec which should be enough to restart the compositor.
     static const int compositorLostMessageDelay = 2000;
 
     m_releaseSelectionTimer.setSingleShot(true);
     m_releaseSelectionTimer.setInterval(compositorLostMessageDelay);
     connect(&m_releaseSelectionTimer, &QTimer::timeout,
             this, &Compositor::releaseCompositorSelection);
 
     m_unusedSupportPropertyTimer.setInterval(compositorLostMessageDelay);
     m_unusedSupportPropertyTimer.setSingleShot(true);
     connect(&m_unusedSupportPropertyTimer, &QTimer::timeout,
             this, &Compositor::deleteUnusedSupportProperties);
 
     // Delay the call to start by one event cycle.
     // The ctor of this class is invoked from the Workspace ctor, that means before
     // Workspace is completely constructed, so calling Workspace::self() would result
     // in undefined behavior. This is fixed by using a delayed invocation.
     if (kwinApp()->platform()->isReady()) {
         QTimer::singleShot(0, this, &Compositor::start);
     }
     connect(kwinApp()->platform(), &Platform::readyChanged, this,
         [this] (bool ready) {
             if (ready) {
                 start();
             } else {
                 stop();
             }
         }, Qt::QueuedConnection
     );
 
     if (qEnvironmentVariableIsSet("KWIN_MAX_FRAMES_TESTED"))
        m_framesToTestForSafety = qEnvironmentVariableIntValue("KWIN_MAX_FRAMES_TESTED");
 
     // register DBus
     new CompositorDBusInterface(this);
 }
 
 Compositor::~Compositor()
 {
     emit aboutToDestroy();
     stop();
     deleteUnusedSupportProperties();
     destroyCompositorSelection();
     s_compositor = nullptr;
 }
 
 bool Compositor::setupStart()
 {
     if (kwinApp()->isTerminating()) {
         // Don't start while KWin is terminating. An event to restart might be lingering
         // in the event queue due to graphics reset.
         return false;
     }
     if (m_state != State::Off) {
         return false;
     }
     m_state = State::Starting;
 
     options->reloadCompositingSettings(true);
 
     setupX11Support();
 
     // There might still be a deleted around, needs to be cleared before
     // creating the scene (BUG 333275).
     if (Workspace::self()) {
         while (!Workspace::self()->deletedList().isEmpty()) {
             Workspace::self()->deletedList().first()->discard();
         }
     }
 
     emit aboutToToggleCompositing();
 
     auto supportedCompositors = kwinApp()->platform()->supportedCompositors();
     const auto userConfigIt = std::find(supportedCompositors.begin(), supportedCompositors.end(),
                                         options->compositingMode());
 
     if (userConfigIt != supportedCompositors.end()) {
         supportedCompositors.erase(userConfigIt);
         supportedCompositors.prepend(options->compositingMode());
     } else {
         qCWarning(KWIN_CORE)
                 << "Configured compositor not supported by Platform. Falling back to defaults";
     }
 
     const auto availablePlugins = KPluginLoader::findPlugins(QStringLiteral("org.kde.kwin.scenes"));
 
     for (auto type : qAsConst(supportedCompositors)) {
         const auto pluginIt = std::find_if(availablePlugins.begin(), availablePlugins.end(),
             [type] (const auto &plugin) {
                 const auto &metaData = plugin.rawData();
                 auto it = metaData.find(QStringLiteral("CompositingType"));
                 if (it != metaData.end()) {
                     if ((*it).toInt() == int{type}) {
                         return true;
                     }
                 }
                 return false;
             });
         if (pluginIt != availablePlugins.end()) {
             std::unique_ptr<SceneFactory>
                     factory{ qobject_cast<SceneFactory*>(pluginIt->instantiate()) };
             if (factory) {
                 m_scene = factory->create(this);
                 if (m_scene) {
                     if (!m_scene->initFailed()) {
                         qCDebug(KWIN_CORE) << "Instantiated compositing plugin:"
                                            << pluginIt->name();
                         break;
                     } else {
                         delete m_scene;
                         m_scene = nullptr;
                     }
                 }
             }
         }
     }
 
     if (m_scene == nullptr || m_scene->initFailed()) {
         qCCritical(KWIN_CORE) << "Failed to initialize compositing, compositing disabled";
         m_state = State::Off;
 
         delete m_scene;
         m_scene = nullptr;
 
         if (m_selectionOwner) {
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         if (!supportedCompositors.contains(NoCompositing)) {
             qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
             qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
             qApp->quit();
         }
         return false;
     }
 
     CompositingType compositingType = m_scene->compositingType();
     if (compositingType & OpenGLCompositing) {
         // Override for OpenGl sub-type OpenGL2Compositing.
         compositingType = OpenGLCompositing;
     }
     kwinApp()->platform()->setSelectedCompositor(compositingType);
 
     if (!Workspace::self() && m_scene && m_scene->compositingType() == QPainterCompositing) {
         // Force Software QtQuick on first startup with QPainter.
         QQuickWindow::setSceneGraphBackend(QSGRendererInterface::Software);
     }
 
     connect(m_scene, &Scene::resetCompositing, this, &Compositor::reinitialize);
     emit sceneCreated();
 
     return true;
 }
 
 void Compositor::claimCompositorSelection()
 {
     if (!m_selectionOwner) {
         char selection_name[ 100 ];
         sprintf(selection_name, "_NET_WM_CM_S%d", Application::x11ScreenNumber());
         m_selectionOwner = new CompositorSelectionOwner(selection_name);
         connect(m_selectionOwner, &CompositorSelectionOwner::lostOwnership,
                 this, &Compositor::stop);
     }
 
     if (!m_selectionOwner) {
         // No X11 yet.
         return;
     }
     if (!m_selectionOwner->owning()) {
         // Force claim ownership.
         m_selectionOwner->claim(true);
         m_selectionOwner->setOwning(true);
     }
 }
 
 void Compositor::setupX11Support()
 {
     auto *con = kwinApp()->x11Connection();
     if (!con) {
         delete m_selectionOwner;
         m_selectionOwner = nullptr;
         return;
     }
     claimCompositorSelection();
     xcb_composite_redirect_subwindows(con, kwinApp()->x11RootWindow(),
                                       XCB_COMPOSITE_REDIRECT_MANUAL);
 }
 
 void Compositor::startupWithWorkspace()
 {
     connect(kwinApp(), &Application::x11ConnectionChanged,
             this, &Compositor::setupX11Support, Qt::UniqueConnection);
     Workspace::self()->markXStackingOrderAsDirty();
     Q_ASSERT(m_scene);
 
     connect(workspace(), &Workspace::destroyed, this, [this] { compositeTimer.stop(); });
     setupX11Support();
     fpsInterval = options->maxFpsInterval();
 
-    if (m_scene->syncsToVBlank()) {
-        // If we do vsync, set the fps to the next multiple of the vblank rate.
-        vBlankInterval = milliToNano(1000) / currentRefreshRate();
-        fpsInterval = qMax((fpsInterval / vBlankInterval) * vBlankInterval, vBlankInterval);
-    } else {
-        // No vsync - DO NOT set "0", would cause div-by-zero segfaults.
-        vBlankInterval = milliToNano(1);
-    }
+    const auto rate = currentRefreshRate();
+    Q_ASSERT(rate != 0); // There is a fallback in options.cpp, so why check at all?
+
+    // If we do vsync, set the fps to the next multiple of the vblank rate.
+    vBlankInterval = milliToNano(1000) / currentRefreshRate();
+    fpsInterval = qMax((fpsInterval / vBlankInterval) * vBlankInterval, vBlankInterval);
 
     // Sets also the 'effects' pointer.
     kwinApp()->platform()->createEffectsHandler(this, m_scene);
     connect(Workspace::self(), &Workspace::deletedRemoved, m_scene, &Scene::removeToplevel);
     connect(effects, &EffectsHandler::screenGeometryChanged, this, &Compositor::addRepaintFull);
 
     for (X11Client *c : Workspace::self()->clientList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (X11Client *c : Workspace::self()->desktopList()) {
         c->setupCompositing();
     }
     for (Unmanaged *c : Workspace::self()->unmanagedList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (InternalClient *client : workspace()->internalClients()) {
         client->setupCompositing();
         client->updateShadow();
     }
 
     if (auto *server = waylandServer()) {
         const auto clients = server->clients();
         for (XdgShellClient *c : clients) {
             c->setupCompositing();
             c->updateShadow();
         }
     }
 
     m_state = State::On;
     emit compositingToggled(true);
 
     if (m_releaseSelectionTimer.isActive()) {
         m_releaseSelectionTimer.stop();
     }
 
     // Render at least once.
     addRepaintFull();
     performCompositing();
 }
 
 void Compositor::scheduleRepaint()
 {
     if (!compositeTimer.isActive())
         setCompositeTimer();
 }
 
 void Compositor::stop()
 {
     if (m_state == State::Off || m_state == State::Stopping) {
         return;
     }
     m_state = State::Stopping;
     emit aboutToToggleCompositing();
 
     m_releaseSelectionTimer.start();
 
     // Some effects might need access to effect windows when they are about to
     // be destroyed, for example to unreference deleted windows, so we have to
     // make sure that effect windows outlive effects.
     delete effects;
     effects = nullptr;
 
     if (Workspace::self()) {
         for (X11Client *c : Workspace::self()->clientList()) {
             m_scene->removeToplevel(c);
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             m_scene->removeToplevel(c);
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             m_scene->removeToplevel(c);
         }
         for (InternalClient *client : workspace()->internalClients()) {
             m_scene->removeToplevel(client);
         }
         for (X11Client *c : Workspace::self()->clientList()) {
             c->finishCompositing();
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             c->finishCompositing();
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             c->finishCompositing();
         }
         for (InternalClient *client : workspace()->internalClients()) {
             client->finishCompositing();
         }
         if (auto *con = kwinApp()->x11Connection()) {
             xcb_composite_unredirect_subwindows(con, kwinApp()->x11RootWindow(),
                                                 XCB_COMPOSITE_REDIRECT_MANUAL);
         }
         while (!workspace()->deletedList().isEmpty()) {
             workspace()->deletedList().first()->discard();
         }
     }
 
     if (waylandServer()) {
         for (XdgShellClient *c : waylandServer()->clients()) {
             m_scene->removeToplevel(c);
         }
         for (XdgShellClient *c : waylandServer()->clients()) {
             c->finishCompositing();
         }
     }
 
     delete m_scene;
     m_scene = nullptr;
     compositeTimer.stop();
     repaints_region = QRegion();
 
     m_state = State::Off;
     emit compositingToggled(false);
 }
 
 void Compositor::destroyCompositorSelection()
 {
     delete m_selectionOwner;
     m_selectionOwner = nullptr;
 }
 
 void Compositor::releaseCompositorSelection()
 {
     switch (m_state) {
     case State::On:
         // We are compositing at the moment. Don't release.
         break;
     case State::Off:
         if (m_selectionOwner) {
             qCDebug(KWIN_CORE) << "Releasing compositor selection";
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         break;
     case State::Starting:
     case State::Stopping:
         // Still starting or shutting down the compositor. Starting might fail
         // or after stopping a restart might follow. So test again later on.
         m_releaseSelectionTimer.start();
         break;
     }
 }
 
 void Compositor::keepSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties.removeAll(atom);
 }
 
 void Compositor::removeSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties << atom;
     m_unusedSupportPropertyTimer.start();
 }
 
 void Compositor::deleteUnusedSupportProperties()
 {
     if (m_state == State::Starting || m_state == State::Stopping) {
         // Currently still maybe restarting the compositor.
         m_unusedSupportPropertyTimer.start();
         return;
     }
     if (auto *con = kwinApp()->x11Connection()) {
         for (const xcb_atom_t &atom : qAsConst(m_unusedSupportProperties)) {
             // remove property from root window
             xcb_delete_property(con, kwinApp()->x11RootWindow(), atom);
         }
         m_unusedSupportProperties.clear();
     }
 }
 
 void Compositor::configChanged()
 {
     reinitialize();
     addRepaintFull();
 }
 
 void Compositor::reinitialize()
 {
     // Reparse config. Config options will be reloaded by start()
     kwinApp()->config()->reparseConfiguration();
 
     // Restart compositing
     stop();
     start();
 
     if (effects) { // start() may fail
         effects->reconfigure();
     }
 }
 
 void Compositor::addRepaint(int x, int y, int w, int h)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += QRegion(x, y, w, h);
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRect& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRegion& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaintFull()
 {
     if (m_state != State::On) {
         return;
     }
     const QSize &s = screens()->size();
     repaints_region = QRegion(0, 0, s.width(), s.height());
     scheduleRepaint();
 }
 
 void Compositor::timerEvent(QTimerEvent *te)
 {
     if (te->timerId() == compositeTimer.timerId()) {
         performCompositing();
     } else
         QObject::timerEvent(te);
 }
 
 void Compositor::aboutToSwapBuffers()
 {
     Q_ASSERT(!m_bufferSwapPending);
 
     m_bufferSwapPending = true;
 }
 
 void Compositor::bufferSwapComplete()
 {
     Q_ASSERT(m_bufferSwapPending);
     m_bufferSwapPending = false;
 
     emit bufferSwapCompleted();
 
     if (m_composeAtSwapCompletion) {
         m_composeAtSwapCompletion = false;
         performCompositing();
     }
 }
 
 void Compositor::performCompositing()
 {
     // If a buffer swap is still pending, we return to the event loop and
     // continue processing events until the swap has completed.
     if (m_bufferSwapPending) {
         m_composeAtSwapCompletion = true;
         compositeTimer.stop();
         return;
     }
 
     // If outputs are disabled, we return to the event loop and
     // continue processing events until the outputs are enabled again
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         compositeTimer.stop();
         return;
     }
 
     // Create a list of all windows in the stacking order
     ToplevelList windows = Workspace::self()->xStackingOrder();
     ToplevelList damaged;
 
     // Reset the damage state of each window and fetch the damage region
     // without waiting for a reply
     for (Toplevel *win : windows) {
         if (win->resetAndFetchDamage()) {
             damaged << win;
         }
     }
 
     if (damaged.count() > 0) {
         m_scene->triggerFence();
         if (auto c = kwinApp()->x11Connection()) {
             xcb_flush(c);
         }
     }
 
     // Move elevated windows to the top of the stacking order
     for (EffectWindow *c : static_cast<EffectsHandlerImpl *>(effects)->elevatedWindows()) {
         Toplevel *t = static_cast<EffectWindowImpl *>(c)->window();
         windows.removeAll(t);
         windows.append(t);
     }
 
     // Get the replies
     for (Toplevel *win : damaged) {
         // Discard the cached lanczos texture
         if (win->effectWindow()) {
             const QVariant texture = win->effectWindow()->data(LanczosCacheRole);
             if (texture.isValid()) {
                 delete static_cast<GLTexture *>(texture.value<void*>());
                 win->effectWindow()->setData(LanczosCacheRole, QVariant());
             }
         }
 
         win->getDamageRegionReply();
     }
 
     if (repaints_region.isEmpty() && !windowRepaintsPending()) {
         m_scene->idle();
         m_timeSinceLastVBlank = fpsInterval - (options->vBlankTime() + 1); // means "start now"
         // Note: It would seem here we should undo suspended unredirect, but when scenes need
         // it for some reason, e.g. transformations or translucency, the next pass that does not
         // need this anymore and paints normally will also reset the suspended unredirect.
         // Otherwise the window would not be painted normally anyway.
         compositeTimer.stop();
         return;
     }
 
     // Skip windows that are not yet ready for being painted and if screen is locked skip windows
     // that are neither lockscreen nor inputmethod windows.
     //
     // TODO? This cannot be used so carelessly - needs protections against broken clients, the
     // window should not get focus before it's displayed, handle unredirected windows properly and
     // so on.
     for (Toplevel *win : windows) {
         if (!win->readyForPainting()) {
             windows.removeAll(win);
         }
         if (waylandServer() && waylandServer()->isScreenLocked()) {
             if(!win->isLockScreen() && !win->isInputMethod()) {
                 windows.removeAll(win);
             }
         }
     }
 
     QRegion repaints = repaints_region;
     // clear all repaints, so that post-pass can add repaints for the next repaint
     repaints_region = QRegion();
 
     if (m_framesToTestForSafety > 0 && (m_scene->compositingType() & OpenGLCompositing)) {
         kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreFrame);
     }
     m_timeSinceLastVBlank = m_scene->paint(repaints, windows);
     if (m_framesToTestForSafety > 0) {
         if (m_scene->compositingType() & OpenGLCompositing) {
             kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostFrame);
         }
         m_framesToTestForSafety--;
         if (m_framesToTestForSafety == 0 && (m_scene->compositingType() & OpenGLCompositing)) {
             kwinApp()->platform()->createOpenGLSafePoint(
                 Platform::OpenGLSafePoint::PostLastGuardedFrame);
         }
     }
 
     if (waylandServer()) {
         const auto currentTime = static_cast<quint32>(m_monotonicClock.elapsed());
         for (Toplevel *win : qAsConst(windows)) {
             if (auto surface = win->surface()) {
                 surface->frameRendered(currentTime);
             }
         }
     }
 
     // Stop here to ensure *we* cause the next repaint schedule - not some effect
     // through m_scene->paint().
     compositeTimer.stop();
 
     // Trigger at least one more pass even if there would be nothing to paint, so that scene->idle()
     // is called the next time. If there would be nothing pending, it will not restart the timer and
     // scheduleRepaint() would restart it again somewhen later, called from functions that
     // would again add something pending.
-    if (m_bufferSwapPending && m_scene->syncsToVBlank()) {
+    if (m_bufferSwapPending) {
         m_composeAtSwapCompletion = true;
     } else {
         scheduleRepaint();
     }
 }
 
 template <class T>
 static bool repaintsPending(const QList<T*> &windows)
 {
     return std::any_of(windows.begin(), windows.end(),
                        [](T *t) { return !t->repaints().isEmpty(); });
 }
 
 bool Compositor::windowRepaintsPending() const
 {
     if (repaintsPending(Workspace::self()->clientList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->desktopList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->unmanagedList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->deletedList())) {
         return true;
     }
     if (auto *server = waylandServer()) {
         const auto &clients = server->clients();
         auto test = [](XdgShellClient *c) {
             return c->readyForPainting() && !c->repaints().isEmpty();
         };
         if (std::any_of(clients.begin(), clients.end(), test)) {
             return true;
         }
     }
     const auto &internalClients = workspace()->internalClients();
     auto internalTest = [] (InternalClient *client) {
         return client->isShown(true) && !client->repaints().isEmpty();
     };
     if (std::any_of(internalClients.begin(), internalClients.end(), internalTest)) {
         return true;
     }
     return false;
 }
 
 void Compositor::setCompositeTimer()
 {
     if (m_state != State::On) {
         return;
     }
 
     // Don't start the timer if we're waiting for a swap event
     if (m_bufferSwapPending && m_composeAtSwapCompletion)
         return;
 
     // Don't start the timer if all outputs are disabled
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         return;
     }
 
     uint waitTime = 1;
 
     if (m_scene->blocksForRetrace()) {
 
         // TODO: make vBlankTime dynamic?!
         // It's required because glXWaitVideoSync will *likely* block a full frame if one enters
         // a retrace pass which can last a variable amount of time, depending on the actual screen
         // Now, my ooold 19" CRT can do such retrace so that 2ms are entirely sufficient,
         // while another ooold 15" TFT requires about 6ms
 
         qint64 padding = m_timeSinceLastVBlank;
         if (padding > fpsInterval) {
             // We're at low repaints or spent more time in painting than the user wanted to wait
             // for that frame. Align to next vblank:
             padding = vBlankInterval - (padding % vBlankInterval);
         } else {
             // Align to the next maxFps tick:
             // "remaining time of the first vsync" + "time for the other vsyncs of the frame"
             padding = ((vBlankInterval - padding % vBlankInterval) +
                        (fpsInterval / vBlankInterval - 1) * vBlankInterval);
         }
 
         if (padding < options->vBlankTime()) {
             // We'll likely miss this frame so we add one:
             waitTime = nanoToMilli(padding + vBlankInterval - options->vBlankTime());
         } else {
             waitTime = nanoToMilli(padding - options->vBlankTime());
         }
     }
     else { // w/o blocking vsync we just jump to the next demanded tick
         if (fpsInterval > m_timeSinceLastVBlank) {
             waitTime = nanoToMilli(fpsInterval - m_timeSinceLastVBlank);
             if (!waitTime) {
                 // Will ensure we don't block out the eventloop - the system's just not faster ...
                 waitTime = 1;
             }
         }
-        /* else if (m_scene->syncsToVBlank() && m_timeSinceLastVBlank - fpsInterval < (vBlankInterval<<1)) {
+        /* else if (m_timeSinceLastVBlank - fpsInterval < (vBlankInterval<<1)) {
             // NOTICE - "for later" ------------------------------------------------------------------
             // It can happen that we push two frames within one refresh cycle.
             // Swapping will then block even with triple buffering when the GPU does not discard but
             // queues frames
             // now here's the mean part: if we take that as "OMG, we're late - next frame ASAP",
             // there'll immediately be 2 frames in the pipe, swapping will block, we think we're
             // late ... ewww
             // so instead we pad to the clock again and add 2ms safety to ensure the pipe is really
             // free
             // NOTICE: obviously m_timeSinceLastVBlank can be too big because we're too slow as well
             // So if this code was enabled, we'd needlessly half the framerate once more (15 instead of 30)
             waitTime = nanoToMilli(vBlankInterval - (m_timeSinceLastVBlank - fpsInterval)%vBlankInterval) + 2;
         }*/
         else {
             // "0" would be sufficient here, but the compositor isn't the WMs only task.
             waitTime = 1;
         }
     }
     // Force 4fps minimum:
     compositeTimer.start(qMin(waitTime, 250u), this);
 }
 
 bool Compositor::isActive()
 {
     return m_state == State::On;
 }
 
 WaylandCompositor::WaylandCompositor(QObject *parent)
     : Compositor(parent)
 {
     connect(kwinApp(), &Application::x11ConnectionAboutToBeDestroyed,
             this, &WaylandCompositor::destroyCompositorSelection);
 }
 
 void WaylandCompositor::toggleCompositing()
 {
     // For the shortcut. Not possible on Wayland because we always composite.
 }
 
 void WaylandCompositor::start()
 {
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
 
     if (Workspace::self()) {
         startupWithWorkspace();
     } else {
         connect(kwinApp(), &Application::workspaceCreated,
                 this, &WaylandCompositor::startupWithWorkspace);
     }
 }
 
 int WaylandCompositor::refreshRate() const
 {
     // TODO: This makes no sense on Wayland. First step would be to atleast
     //       set the refresh rate to the highest available one. Second step
     //       would be to not use a uniform value at all but per screen.
     return KWin::currentRefreshRate();
 }
 
 X11Compositor::X11Compositor(QObject *parent)
     : Compositor(parent)
     , m_suspended(options->isUseCompositing() ? NoReasonSuspend : UserSuspend)
     , m_xrrRefreshRate(0)
 {
 }
 
 void X11Compositor::toggleCompositing()
 {
     if (m_suspended) {
         // Direct user call; clear all bits.
         resume(AllReasonSuspend);
     } else {
         // But only set the user one (sufficient to suspend).
         suspend(UserSuspend);
     }
 }
 
 void X11Compositor::reinitialize()
 {
     // Resume compositing if suspended.
     m_suspended = NoReasonSuspend;
     Compositor::reinitialize();
 }
 
 void X11Compositor::configChanged()
 {
     if (m_suspended) {
         stop();
         return;
     }
     Compositor::configChanged();
 }
 
 void X11Compositor::suspend(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended |= reason;
 
     if (reason & ScriptSuspend) {
         // When disabled show a shortcut how the user can get back compositing.
         const auto shortcuts = KGlobalAccel::self()->shortcut(
             workspace()->findChild<QAction*>(QStringLiteral("Suspend Compositing")));
         if (!shortcuts.isEmpty()) {
             // Display notification only if there is the shortcut.
             const QString message =
                     i18n("Desktop effects have been suspended by another application.<br/>"
                          "You can resume using the '%1' shortcut.",
                          shortcuts.first().toString(QKeySequence::NativeText));
             KNotification::event(QStringLiteral("compositingsuspendeddbus"), message);
         }
     }
     stop();
 }
 
 void X11Compositor::resume(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended &= ~reason;
     start();
 }
 
 void X11Compositor::start()
 {
     if (m_suspended) {
         QStringList reasons;
         if (m_suspended & UserSuspend) {
             reasons << QStringLiteral("Disabled by User");
         }
         if (m_suspended & BlockRuleSuspend) {
             reasons << QStringLiteral("Disabled by Window");
         }
         if (m_suspended & ScriptSuspend) {
             reasons << QStringLiteral("Disabled by Script");
         }
         qCDebug(KWIN_CORE) << "Compositing is suspended, reason:" << reasons;
         return;
     } else if (!kwinApp()->platform()->compositingPossible()) {
         qCCritical(KWIN_CORE) << "Compositing is not possible";
         return;
     }
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
     m_xrrRefreshRate = KWin::currentRefreshRate();
     startupWithWorkspace();
 }
 void X11Compositor::performCompositing()
 {
     if (scene()->usesOverlayWindow() && !isOverlayWindowVisible()) {
         // Return since nothing is visible.
         return;
     }
     Compositor::performCompositing();
 }
 
 bool X11Compositor::checkForOverlayWindow(WId w) const
 {
     if (!scene()) {
         // No scene, so it cannot be the overlay window.
         return false;
     }
     if (!scene()->overlayWindow()) {
         // No overlay window, it cannot be the overlay.
         return false;
     }
     // Compare the window ID's.
     return w == scene()->overlayWindow()->window();
 }
 
 bool X11Compositor::isOverlayWindowVisible() const
 {
     if (!scene()) {
         return false;
     }
     if (!scene()->overlayWindow()) {
         return false;
     }
     return scene()->overlayWindow()->isVisible();
 }
 
 int X11Compositor::refreshRate() const
 {
     return m_xrrRefreshRate;
 }
 
 void X11Compositor::updateClientCompositeBlocking(X11Client *c)
 {
     if (c) {
         if (c->isBlockingCompositing()) {
             // Do NOT attempt to call suspend(true) from within the eventchain!
             if (!(m_suspended & BlockRuleSuspend))
                 QMetaObject::invokeMethod(this, [this]() {
                         suspend(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
     else if (m_suspended & BlockRuleSuspend) {
         // If !c we just check if we can resume in case a blocking client was lost.
         bool shouldResume = true;
 
         for (ClientList::ConstIterator it = Workspace::self()->clientList().constBegin();
              it != Workspace::self()->clientList().constEnd(); ++it) {
             if ((*it)->isBlockingCompositing()) {
                 shouldResume = false;
                 break;
             }
         }
         if (shouldResume) {
             // Do NOT attempt to call suspend(false) from within the eventchain!
                 QMetaObject::invokeMethod(this, [this]() {
                         resume(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
 }
 
 X11Compositor *X11Compositor::self()
 {
     return qobject_cast<X11Compositor *>(Compositor::self());
 }
 
 }
 
 // included for CompositorSelectionOwner
 #include "composite.moc"
diff --git a/kcmkwin/kwincompositing/compositing.cpp b/kcmkwin/kwincompositing/compositing.cpp
index b43f7cea2..eb63d977a 100644
--- a/kcmkwin/kwincompositing/compositing.cpp
+++ b/kcmkwin/kwincompositing/compositing.cpp
@@ -1,546 +1,542 @@
 /**************************************************************************
 * KWin - the KDE window manager                                          *
 * This file is part of the KDE project.                                  *
 *                                                                        *
 * Copyright (C) 2013 Antonis Tsiapaliokas <kok3rs@gmail.com>             *
 * Copyright (C) 2013 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 "compositing.h"
 #include <kwin_compositing_interface.h>
 
 #include <KCModuleProxy>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QHash>
 #include <QDebug>
 
 namespace KWin {
 namespace Compositing {
 
 Compositing::Compositing(QObject *parent)
     : QObject(parent)
     , m_animationSpeed(1.0)
     , m_windowThumbnail(0)
     , m_glScaleFilter(0)
     , m_xrScaleFilter(false)
     , m_glSwapStrategy(0)
     , m_compositingType(0)
     , m_compositingEnabled(true)
     , m_changed(false)
     , m_openGLPlatformInterfaceModel(new OpenGLPlatformInterfaceModel(this))
     , m_openGLPlatformInterface(0)
     , m_windowsBlockCompositing(true)
     , m_compositingInterface(new OrgKdeKwinCompositingInterface(QStringLiteral("org.kde.KWin"), QStringLiteral("/Compositor"), QDBusConnection::sessionBus(), this))
     , m_config(KSharedConfig::openConfig("kwinrc"))
 {
     reset();
     connect(this, &Compositing::animationSpeedChanged,       this, &Compositing::changed);
     connect(this, &Compositing::windowThumbnailChanged,      this, &Compositing::changed);
     connect(this, &Compositing::glScaleFilterChanged,        this, &Compositing::changed);
     connect(this, &Compositing::xrScaleFilterChanged,        this, &Compositing::changed);
     connect(this, &Compositing::glSwapStrategyChanged,       this, &Compositing::changed);
     connect(this, &Compositing::compositingTypeChanged,      this, &Compositing::changed);
     connect(this, &Compositing::compositingEnabledChanged,   this, &Compositing::changed);
     connect(this, &Compositing::openGLPlatformInterfaceChanged, this, &Compositing::changed);
     connect(this, &Compositing::windowsBlockCompositingChanged, this, &Compositing::changed);
 
     connect(this, &Compositing::changed, [this]{
         m_changed = true;
     });
 }
 
 void Compositing::reset()
 {
     KConfigGroup globalConfig(m_config, QStringLiteral("KDE"));
     setAnimationSpeed(globalConfig.readEntry("AnimationDurationFactor", 1.0));
 
     KConfigGroup kwinConfig(m_config, QStringLiteral("Compositing"));
     setWindowThumbnail(kwinConfig.readEntry("HiddenPreviews", 5) - 4);
     setGlScaleFilter(kwinConfig.readEntry("GLTextureFilter", 2));
     setXrScaleFilter(kwinConfig.readEntry("XRenderSmoothScale", false));
     setCompositingEnabled(kwinConfig.readEntry("Enabled", true));
 
     auto swapStrategy = [&kwinConfig]() {
         const QString glSwapStrategyValue = kwinConfig.readEntry("GLPreferBufferSwap", "a");
 
-        if (glSwapStrategyValue == "n") {
+        if (glSwapStrategyValue == "a") {
             return 0;
-        } else if (glSwapStrategyValue == "a") {
-            return 1;
         } else if (glSwapStrategyValue == "e") {
-            return 2;
+            return 1;
         } else if (glSwapStrategyValue == "p") {
-            return 3;
+            return 2;
         } else if (glSwapStrategyValue == "c") {
-            return 4;
+            return 3;
         }
         return 0;
     };
     setGlSwapStrategy(swapStrategy());
 
     auto type = [&kwinConfig]{
         const QString backend = kwinConfig.readEntry("Backend", "OpenGL");
         const bool glCore = kwinConfig.readEntry("GLCore", false);
 
         if (backend == QStringLiteral("OpenGL")) {
             if (glCore) {
                 return CompositingType::OPENGL31_INDEX;
             } else {
                 return CompositingType::OPENGL20_INDEX;
             }
         } else {
             return CompositingType::XRENDER_INDEX;
         }
     };
     setCompositingType(type());
 
     const QModelIndex index = m_openGLPlatformInterfaceModel->indexForKey(kwinConfig.readEntry("GLPlatformInterface", "glx"));
     setOpenGLPlatformInterface(index.isValid() ? index.row() : 0);
 
     setWindowsBlockCompositing(kwinConfig.readEntry("WindowsBlockCompositing", true));
 
     m_changed = false;
 }
 
 void Compositing::defaults()
 {
     setAnimationSpeed(1.0);
     setWindowThumbnail(1);
     setGlScaleFilter(2);
     setXrScaleFilter(false);
     setGlSwapStrategy(1);
     setCompositingType(CompositingType::OPENGL20_INDEX);
     const QModelIndex index = m_openGLPlatformInterfaceModel->indexForKey(QStringLiteral("glx"));
     setOpenGLPlatformInterface(index.isValid() ? index.row() : 0);
     setWindowsBlockCompositing(true);
     m_changed = true;
 }
 
 bool Compositing::OpenGLIsUnsafe() const
 {
     KConfigGroup kwinConfig(m_config, "Compositing");
     return kwinConfig.readEntry("OpenGLIsUnsafe", true);
 }
 
 bool Compositing::OpenGLIsBroken()
 {
     KConfigGroup kwinConfig(m_config, "Compositing");
 
     QString oldBackend = kwinConfig.readEntry("Backend", "OpenGL");
     kwinConfig.writeEntry("Backend", "OpenGL");
     kwinConfig.sync();
 
     if (m_compositingInterface->openGLIsBroken()) {
         kwinConfig.writeEntry("Backend", oldBackend);
         kwinConfig.sync();
         return true;
     }
 
     kwinConfig.writeEntry("OpenGLIsUnsafe", false);
     kwinConfig.sync();
     return false;
 }
 
 void Compositing::reenableOpenGLDetection()
 {
     KConfigGroup kwinConfig(m_config, "Compositing");
     kwinConfig.writeEntry("OpenGLIsUnsafe", false);
     kwinConfig.sync();
 }
 
 qreal Compositing::animationSpeed() const
 {
     return m_animationSpeed;
 }
 
 int Compositing::windowThumbnail() const
 {
     return m_windowThumbnail;
 }
 
 int Compositing::glScaleFilter() const
 {
     return m_glScaleFilter;
 }
 
 bool Compositing::xrScaleFilter() const
 {
     return m_xrScaleFilter;
 }
 
 int Compositing::glSwapStrategy() const
 {
     return m_glSwapStrategy;
 }
 
 int Compositing::compositingType() const
 {
     return m_compositingType;
 }
 
 bool Compositing::compositingEnabled() const
 {
     return m_compositingEnabled;
 }
 
 void Compositing::setAnimationSpeed(qreal speed)
 {
     if (speed == m_animationSpeed) {
         return;
     }
     m_animationSpeed = speed;
     emit animationSpeedChanged(speed);
 }
 
 void Compositing::setGlScaleFilter(int index)
 {
     if (index == m_glScaleFilter) {
         return;
     }
     m_glScaleFilter = index;
     emit glScaleFilterChanged(index);
 }
 
 void Compositing::setGlSwapStrategy(int strategy)
 {
     if (strategy == m_glSwapStrategy) {
         return;
     }
     m_glSwapStrategy = strategy;
     emit glSwapStrategyChanged(strategy);
 }
 
 void Compositing::setWindowThumbnail(int index)
 {
     if (index == m_windowThumbnail) {
         return;
     }
     m_windowThumbnail = index;
     emit windowThumbnailChanged(index);
 }
 
 void Compositing::setXrScaleFilter(bool filter)
 {
     if (filter == m_xrScaleFilter) {
         return;
     }
     m_xrScaleFilter = filter;
     emit xrScaleFilterChanged(filter);
 }
 
 void Compositing::setCompositingType(int index)
 {
     if (index == m_compositingType) {
         return;
     }
     m_compositingType = index;
     emit compositingTypeChanged(index);
 }
 
 void Compositing::setCompositingEnabled(bool enabled)
 {
     if (compositingRequired()) {
         return;
     }
     if (enabled == m_compositingEnabled) {
         return;
     }
 
     m_compositingEnabled = enabled;
     emit compositingEnabledChanged(enabled);
 }
 
 void Compositing::save()
 {
     // this writes to the KDE group of the kwinrc, when loading we rely on kconfig cascading to
     // load a global value, or allow a kwin override
     KConfigGroup generalConfig(m_config, "KDE");
     if (!isRunningPlasma()) {
         generalConfig.writeEntry("AnimationDurationFactor", animationSpeed());
     }
     KConfigGroup kwinConfig(m_config, "Compositing");
 
     kwinConfig.writeEntry("HiddenPreviews", windowThumbnail() + 4);
     kwinConfig.writeEntry("GLTextureFilter", glScaleFilter());
     kwinConfig.writeEntry("XRenderSmoothScale", xrScaleFilter());
     if (!compositingRequired()) {
         kwinConfig.writeEntry("Enabled", compositingEnabled());
     }
     auto swapStrategy = [this] {
         switch (glSwapStrategy()) {
-            case 0:
-                return QStringLiteral("n");
-            case 2:
+            case 1:
                 return QStringLiteral("e");
-            case 3:
+            case 2:
                 return QStringLiteral("p");
-            case 4:
+            case 3:
                 return QStringLiteral("c");
-            case 1:
+            case 0:
             default:
                 return QStringLiteral("a");
         }
     };
     kwinConfig.writeEntry("GLPreferBufferSwap", swapStrategy());
     QString backend;
     bool glCore = false;
     switch (compositingType()) {
     case CompositingType::OPENGL31_INDEX:
         backend = "OpenGL";
         glCore = true;
         break;
     case CompositingType::OPENGL20_INDEX:
         backend = "OpenGL";
         glCore = false;
         break;
     case CompositingType::XRENDER_INDEX:
         backend = "XRender";
         glCore = false;
         break;
     }
     kwinConfig.writeEntry("Backend", backend);
     kwinConfig.writeEntry("GLCore", glCore);
     if (!compositingRequired()) {
         kwinConfig.writeEntry("WindowsBlockCompositing", windowsBlockCompositing());
     }
     kwinConfig.sync();
 
     if (m_changed) {
         // Send signal to all kwin instances
         QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/Compositor"),
                                                           QStringLiteral("org.kde.kwin.Compositing"),
                                                           QStringLiteral("reinit"));
         QDBusConnection::sessionBus().send(message);
         m_changed = false;
     }
 }
 
 OpenGLPlatformInterfaceModel *Compositing::openGLPlatformInterfaceModel() const
 {
     return m_openGLPlatformInterfaceModel;
 }
 
 int Compositing::openGLPlatformInterface() const
 {
     return m_openGLPlatformInterface;
 }
 
 void Compositing::setOpenGLPlatformInterface(int interface)
 {
     if (m_openGLPlatformInterface == interface) {
         return;
     }
     m_openGLPlatformInterface = interface;
     emit openGLPlatformInterfaceChanged(interface);
 }
 
 bool Compositing::windowsBlockCompositing() const
 {
     return m_windowsBlockCompositing;
 }
 
 void Compositing::setWindowsBlockCompositing(bool set)
 {
     if (compositingRequired()) {
         return;
     }
     if (m_windowsBlockCompositing == set) {
         return;
     }
     m_windowsBlockCompositing = set;
     emit windowsBlockCompositingChanged(set);
 }
 
 bool Compositing::compositingRequired() const
 {
     return m_compositingInterface->platformRequiresCompositing();
 }
 
 bool Compositing::isRunningPlasma()
 {
     return qgetenv("XDG_CURRENT_DESKTOP") == "KDE";
 }
 
 CompositingType::CompositingType(QObject *parent)
     : QAbstractItemModel(parent) {
 
     generateCompositing();
 }
 
 void CompositingType::generateCompositing()
 {
     QHash<QString, CompositingType::CompositingTypeIndex> compositingTypes;
 
     compositingTypes[i18n("OpenGL 3.1")] = CompositingType::OPENGL31_INDEX;
     compositingTypes[i18n("OpenGL 2.0")] = CompositingType::OPENGL20_INDEX;
     compositingTypes[i18n("XRender")] = CompositingType::XRENDER_INDEX;
 
     CompositingData data;
     beginResetModel();
     auto it = compositingTypes.begin();
     while (it != compositingTypes.end()) {
         data.name = it.key();
         data.type = it.value();
         m_compositingList << data;
         it++;
     }
 
     std::sort(m_compositingList.begin(), m_compositingList.end(), [](const CompositingData &a, const CompositingData &b) {
             return a.type < b.type;
     });
     endResetModel();
 }
 
 QHash< int, QByteArray > CompositingType::roleNames() const
 {
     QHash<int, QByteArray> roleNames;
     roleNames[NameRole] = "NameRole";
     roleNames[TypeRole] = QByteArrayLiteral("type");
     return roleNames;
 }
 
 QModelIndex CompositingType::index(int row, int column, const QModelIndex &parent) const
 {
 
 if (parent.isValid() || column > 0 || column < 0 || row < 0 || row >= m_compositingList.count()) {
         return QModelIndex();
     }
 
     return createIndex(row, column);
 }
 
 QModelIndex CompositingType::parent(const QModelIndex &child) const
 {
     Q_UNUSED(child)
 
     return QModelIndex();
 }
 
 int CompositingType::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 int CompositingType::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
     return m_compositingList.count();
 }
 
 QVariant CompositingType::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     switch (role) {
         case Qt::DisplayRole:
         case NameRole:
             return m_compositingList.at(index.row()).name;
         case TypeRole:
             return m_compositingList.at(index.row()).type;
         default:
             return QVariant();
     }
 }
 
 int CompositingType::compositingTypeForIndex(int row) const
 {
     return index(row, 0).data(TypeRole).toInt();
 }
 
 int CompositingType::indexForCompositingType(int type) const
 {
     for (int i = 0; i < m_compositingList.count(); ++i) {
         if (m_compositingList.at(i).type == type) {
             return i;
         }
     }
     return -1;
 }
 
 OpenGLPlatformInterfaceModel::OpenGLPlatformInterfaceModel(QObject *parent)
     : QAbstractListModel(parent)
 {
     beginResetModel();
     OrgKdeKwinCompositingInterface interface(QStringLiteral("org.kde.KWin"),
                                              QStringLiteral("/Compositor"),
                                              QDBusConnection::sessionBus());
     m_keys << interface.supportedOpenGLPlatformInterfaces();
     for (const QString &key : m_keys) {
         if (key == QStringLiteral("egl")) {
             m_names << i18nc("OpenGL Platform Interface", "EGL");
         } else if (key == QStringLiteral("glx")) {
             m_names << i18nc("OpenGL Platform Interface", "GLX");
         } else {
             m_names << key;
         }
     }
     endResetModel();
 }
 
 OpenGLPlatformInterfaceModel::~OpenGLPlatformInterfaceModel() = default;
 
 int OpenGLPlatformInterfaceModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
     return m_keys.count();
 }
 
 QHash< int, QByteArray > OpenGLPlatformInterfaceModel::roleNames() const
 {
     return QHash<int, QByteArray>({
         {Qt::DisplayRole, QByteArrayLiteral("display")},
         {Qt::UserRole, QByteArrayLiteral("openglPlatformInterface")}
     });
 }
 
 QVariant OpenGLPlatformInterfaceModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.row() < 0 || index.row() >= m_keys.size() || index.column() != 0) {
         return QVariant();
     }
     switch (role) {
     case Qt::DisplayRole:
         return m_names.at(index.row());
     case Qt::UserRole:
         return m_keys.at(index.row());
     default:
         return QVariant();
     }
 }
 
 QModelIndex OpenGLPlatformInterfaceModel::indexForKey(const QString &key) const
 {
     const int keyIndex = m_keys.indexOf(key);
     if (keyIndex < 0) {
         return QModelIndex();
     }
     return createIndex(keyIndex, 0);
 }
 
 }//end namespace Compositing
 }//end namespace KWin
diff --git a/kcmkwin/kwincompositing/compositing.ui b/kcmkwin/kwincompositing/compositing.ui
index ec30fc32f..45e82fe70 100644
--- a/kcmkwin/kwincompositing/compositing.ui
+++ b/kcmkwin/kwincompositing/compositing.ui
@@ -1,307 +1,302 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>CompositingForm</class>
  <widget class="QWidget" name="CompositingForm">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>526</width>
     <height>395</height>
    </rect>
   </property>
   <layout class="QFormLayout" name="formLayout">
    <property name="fieldGrowthPolicy">
     <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
    </property>
    <item row="0" column="0" colspan="2">
     <layout class="QVBoxLayout" name="verticalLayout_4">
      <item>
       <widget class="KMessageWidget" name="glCrashedWarning">
        <property name="visible">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>OpenGL compositing (the default) has crashed KWin in the past.
 This was most likely due to a driver bug.
 If you think that you have meanwhile upgraded to a stable driver,
 you can reset this protection but be aware that this might result in an immediate crash!
 Alternatively, you might want to use the XRender backend instead.</string>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KMessageWidget" name="scaleWarning">
        <property name="visible">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>Scale method &quot;Accurate&quot; is not supported by all hardware and can cause performance regressions and rendering artifacts.</string>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KMessageWidget" name="tearingWarning">
        <property name="visible">
         <bool>false</bool>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="KMessageWidget" name="windowThumbnailWarning">
        <property name="visible">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>Keeping the window thumbnail always interferes with the minimized state of windows. This can result in windows not suspending their work when minimized.</string>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="1" column="0" colspan="2">
     <widget class="QCheckBox" name="compositingEnabled">
      <property name="text">
       <string>Enable compositor on startup</string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QLabel" name="animationSpeedLabel">
      <property name="text">
       <string>Animation speed:</string>
      </property>
     </widget>
    </item>
    <item row="5" column="0">
     <widget class="QLabel" name="glScaleFilterLabel">
      <property name="text">
       <string>Scale method:</string>
      </property>
     </widget>
    </item>
    <item row="5" column="1">
     <widget class="QComboBox" name="glScaleFilter">
      <item>
       <property name="text">
        <string>Crisp</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Smooth</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Accurate</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="6" column="0">
     <widget class="QLabel" name="xrScaleFilterLabel">
      <property name="text">
       <string>Scale method:</string>
      </property>
     </widget>
    </item>
    <item row="6" column="1">
     <widget class="QComboBox" name="xrScaleFilter">
      <item>
       <property name="text">
        <string>Crisp</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Smooth (slower)</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="7" column="0" colspan="2">
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="8" column="0">
     <widget class="QLabel" name="label_2">
      <property name="text">
       <string>Rendering backend:</string>
      </property>
     </widget>
    </item>
    <item row="8" column="1">
     <widget class="QComboBox" name="type"/>
    </item>
    <item row="9" column="0" colspan="2">
     <widget class="Line" name="line_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item row="10" column="0">
     <widget class="QLabel" name="label_5">
      <property name="text">
       <string>Tearing prevention (&quot;vsync&quot;):</string>
      </property>
     </widget>
    </item>
    <item row="10" column="1">
     <widget class="QComboBox" name="tearingPrevention">
-     <item>
-      <property name="text">
-       <string>Never</string>
-      </property>
-     </item>
      <item>
       <property name="text">
        <string>Automatic</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Only when cheap</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Full screen repaints</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Re-use screen content</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="11" column="0">
     <widget class="QLabel" name="label_6">
      <property name="text">
       <string>Keep window thumbnails:</string>
      </property>
     </widget>
    </item>
    <item row="11" column="1">
     <widget class="QComboBox" name="windowThumbnail">
      <item>
       <property name="text">
        <string>Never</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Only for Shown Windows</string>
       </property>
      </item>
      <item>
       <property name="text">
        <string>Always</string>
       </property>
      </item>
     </widget>
    </item>
    <item row="13" column="1">
     <widget class="QCheckBox" name="windowsBlockCompositing">
      <property name="toolTip">
       <string>Applications can set a hint to block compositing when the window is open.
  This brings performance improvements for e.g. games.
  The setting can be overruled by window-specific rules.</string>
      </property>
      <property name="text">
       <string>Allow applications to block compositing</string>
      </property>
     </widget>
    </item>
    <item row="3" column="1">
     <widget class="QWidget" name="animationSpeedControls" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QSlider" name="animationSpeed">
         <property name="minimum">
          <number>0</number>
         </property>
         <property name="maximum">
          <number>0</number>
         </property>
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
         <property name="tickPosition">
          <enum>QSlider::TicksBelow</enum>
         </property>
         <property name="tickInterval">
          <number>1</number>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="_3">
         <item>
          <widget class="QLabel" name="label_3">
           <property name="text">
            <string>Very slow</string>
           </property>
          </widget>
         </item>
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>40</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QLabel" name="label">
           <property name="text">
            <string>Instant</string>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KMessageWidget</class>
    <extends>QFrame</extends>
    <header>kmessagewidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/options.cpp b/options.cpp
index fc727855f..07534d7c7 100644
--- a/options.cpp
+++ b/options.cpp
@@ -1,1092 +1,1092 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2012 Martin Gräßlin <m.graesslin@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 "options.h"
 #include "config-kwin.h"
 #include "utils.h"
 #include "platform.h"
 
 #ifndef KCMRULES
 
 #include <QProcess>
 
 #include "screens.h"
 #include "settings.h"
 #include <kwinglplatform.h>
 #include <QOpenGLContext>
 
 #endif //KCMRULES
 
 namespace KWin
 {
 
 #ifndef KCMRULES
 
 int currentRefreshRate()
 {
     return Options::currentRefreshRate();
 }
 
 int Options::currentRefreshRate()
 {
     int rate = -1;
     QString syncScreenName(QLatin1String("primary screen"));
     if (options->refreshRate() > 0) {  // use manually configured refresh rate
         rate = options->refreshRate();
     } else if (Screens::self()->count() > 0) {
         // prefer the refreshrate calculated from the screens mode information
         // at least the nvidia driver reports 50Hz BS ... *again*!
         int syncScreen = 0;
         if (Screens::self()->count() > 1) {
             const QByteArray syncDisplayDevice(qgetenv("__GL_SYNC_DISPLAY_DEVICE"));
             // if __GL_SYNC_DISPLAY_DEVICE is exported, the GPU shall sync to that device
             // so we try to use its refresh rate
             if (!syncDisplayDevice.isEmpty()) {
                 for (int i = 0; i < Screens::self()->count(); ++i) {
                     if (Screens::self()->name(i) == syncDisplayDevice) {
                         syncScreenName = Screens::self()->name(i);
                         syncScreen = i;
                         break;
                     }
                 }
             }
         }
         rate = qRound(Screens::self()->refreshRate(syncScreen)); // TODO forward float precision?
     }
 
     // 0Hz or less is invalid, so we fallback to a default rate
     if (rate <= 0)
         rate = 60; // and not shitty 50Hz for sure! *grrr*
 
     // QTimer gives us 1msec (1000Hz) at best, so we ignore anything higher;
     // however, additional throttling prevents very high rates from taking place anyway
     else if (rate > 1000)
         rate = 1000;
     qCDebug(KWIN_CORE) << "Vertical Refresh rate " << rate << "Hz (" << syncScreenName << ")";
     return rate;
 }
 
 Options::Options(QObject *parent)
     : QObject(parent)
     , m_settings(new Settings(kwinApp()->config()))
     , m_focusPolicy(ClickToFocus)
     , m_nextFocusPrefersMouse(false)
     , m_clickRaise(false)
     , m_autoRaise(false)
     , m_autoRaiseInterval(0)
     , m_delayFocusInterval(0)
     , m_shadeHover(false)
     , m_shadeHoverInterval(0)
     , m_separateScreenFocus(false)
     , m_placement(Placement::NoPlacement)
     , m_borderSnapZone(0)
     , m_windowSnapZone(0)
     , m_centerSnapZone(0)
     , m_snapOnlyWhenOverlapping(false)
     , m_rollOverDesktops(false)
     , m_focusStealingPreventionLevel(0)
     , m_killPingTimeout(0)
     , m_hideUtilityWindowsForInactive(false)
     , m_compositingMode(Options::defaultCompositingMode())
     , m_useCompositing(Options::defaultUseCompositing())
     , m_hiddenPreviews(Options::defaultHiddenPreviews())
     , m_glSmoothScale(Options::defaultGlSmoothScale())
     , m_xrenderSmoothScale(Options::defaultXrenderSmoothScale())
     , m_maxFpsInterval(Options::defaultMaxFpsInterval())
     , m_refreshRate(Options::defaultRefreshRate())
     , m_vBlankTime(Options::defaultVBlankTime())
     , m_glStrictBinding(Options::defaultGlStrictBinding())
     , m_glStrictBindingFollowsDriver(Options::defaultGlStrictBindingFollowsDriver())
     , m_glCoreProfile(Options::defaultGLCoreProfile())
     , m_glPreferBufferSwap(Options::defaultGlPreferBufferSwap())
     , m_glPlatformInterface(Options::defaultGlPlatformInterface())
     , m_windowsBlockCompositing(true)
     , OpTitlebarDblClick(Options::defaultOperationTitlebarDblClick())
     , CmdActiveTitlebar1(Options::defaultCommandActiveTitlebar1())
     , CmdActiveTitlebar2(Options::defaultCommandActiveTitlebar2())
     , CmdActiveTitlebar3(Options::defaultCommandActiveTitlebar3())
     , CmdInactiveTitlebar1(Options::defaultCommandInactiveTitlebar1())
     , CmdInactiveTitlebar2(Options::defaultCommandInactiveTitlebar2())
     , CmdInactiveTitlebar3(Options::defaultCommandInactiveTitlebar3())
     , CmdTitlebarWheel(Options::defaultCommandTitlebarWheel())
     , CmdWindow1(Options::defaultCommandWindow1())
     , CmdWindow2(Options::defaultCommandWindow2())
     , CmdWindow3(Options::defaultCommandWindow3())
     , CmdWindowWheel(Options::defaultCommandWindowWheel())
     , CmdAll1(Options::defaultCommandAll1())
     , CmdAll2(Options::defaultCommandAll2())
     , CmdAll3(Options::defaultCommandAll3())
     , CmdAllWheel(Options::defaultCommandAllWheel())
     , CmdAllModKey(Options::defaultKeyCmdAllModKey())
     , electric_border_maximize(false)
     , electric_border_tiling(false)
     , electric_border_corner_ratio(0.0)
     , borderless_maximized_windows(false)
     , show_geometry_tip(false)
     , condensed_title(false)
 {
     m_settings->setDefaults();
     syncFromKcfgc();
 
     m_configWatcher = KConfigWatcher::create(m_settings->sharedConfig());
     connect(m_configWatcher.data(), &KConfigWatcher::configChanged, this, [this](const KConfigGroup &group, const QByteArrayList &names) {
         if (group.name() == QLatin1String("KDE") && names.contains(QByteArrayLiteral("AnimationDurationFactor"))) {
             emit animationSpeedChanged();
         }
     });
 }
 
 Options::~Options()
 {
 }
 
 void Options::setFocusPolicy(FocusPolicy focusPolicy)
 {
     if (m_focusPolicy == focusPolicy) {
         return;
     }
     m_focusPolicy = focusPolicy;
     emit focusPolicyChanged();
     if (m_focusPolicy == ClickToFocus) {
         setAutoRaise(false);
         setAutoRaiseInterval(0);
         setDelayFocusInterval(0);
     }
 }
 
 void Options::setNextFocusPrefersMouse(bool nextFocusPrefersMouse)
 {
     if (m_nextFocusPrefersMouse == nextFocusPrefersMouse) {
         return;
     }
     m_nextFocusPrefersMouse = nextFocusPrefersMouse;
     emit nextFocusPrefersMouseChanged();
 }
 
 void Options::setClickRaise(bool clickRaise)
 {
     if (m_autoRaise) {
         // important: autoRaise implies ClickRaise
         clickRaise = true;
     }
     if (m_clickRaise == clickRaise) {
         return;
     }
     m_clickRaise = clickRaise;
     emit clickRaiseChanged();
 }
 
 void Options::setAutoRaise(bool autoRaise)
 {
     if (m_focusPolicy == ClickToFocus) {
         autoRaise = false;
     }
     if (m_autoRaise == autoRaise) {
         return;
     }
     m_autoRaise = autoRaise;
     if (m_autoRaise) {
         // important: autoRaise implies ClickRaise
         setClickRaise(true);
     }
     emit autoRaiseChanged();
 }
 
 void Options::setAutoRaiseInterval(int autoRaiseInterval)
 {
     if (m_focusPolicy == ClickToFocus) {
         autoRaiseInterval = 0;
     }
     if (m_autoRaiseInterval == autoRaiseInterval) {
         return;
     }
     m_autoRaiseInterval = autoRaiseInterval;
     emit autoRaiseIntervalChanged();
 }
 
 void Options::setDelayFocusInterval(int delayFocusInterval)
 {
     if (m_focusPolicy == ClickToFocus) {
         delayFocusInterval = 0;
     }
     if (m_delayFocusInterval == delayFocusInterval) {
         return;
     }
     m_delayFocusInterval = delayFocusInterval;
     emit delayFocusIntervalChanged();
 }
 
 void Options::setShadeHover(bool shadeHover)
 {
     if (m_shadeHover == shadeHover) {
         return;
     }
     m_shadeHover = shadeHover;
     emit shadeHoverChanged();
 }
 
 void Options::setShadeHoverInterval(int shadeHoverInterval)
 {
     if (m_shadeHoverInterval == shadeHoverInterval) {
         return;
     }
     m_shadeHoverInterval = shadeHoverInterval;
     emit shadeHoverIntervalChanged();
 }
 
 void Options::setSeparateScreenFocus(bool separateScreenFocus)
 {
     if (m_separateScreenFocus == separateScreenFocus) {
         return;
     }
     m_separateScreenFocus = separateScreenFocus;
     emit separateScreenFocusChanged(m_separateScreenFocus);
 }
 
 void Options::setPlacement(int placement)
 {
     if (m_placement == static_cast<Placement::Policy>(placement)) {
         return;
     }
     m_placement = static_cast<Placement::Policy>(placement);
     emit placementChanged();
 }
 
 void Options::setBorderSnapZone(int borderSnapZone)
 {
     if (m_borderSnapZone == borderSnapZone) {
         return;
     }
     m_borderSnapZone = borderSnapZone;
     emit borderSnapZoneChanged();
 }
 
 void Options::setWindowSnapZone(int windowSnapZone)
 {
     if (m_windowSnapZone == windowSnapZone) {
         return;
     }
     m_windowSnapZone = windowSnapZone;
     emit windowSnapZoneChanged();
 }
 
 void Options::setCenterSnapZone(int centerSnapZone)
 {
     if (m_centerSnapZone == centerSnapZone) {
         return;
     }
     m_centerSnapZone = centerSnapZone;
     emit centerSnapZoneChanged();
 }
 
 void Options::setSnapOnlyWhenOverlapping(bool snapOnlyWhenOverlapping)
 {
     if (m_snapOnlyWhenOverlapping == snapOnlyWhenOverlapping) {
         return;
     }
     m_snapOnlyWhenOverlapping = snapOnlyWhenOverlapping;
     emit snapOnlyWhenOverlappingChanged();
 }
 
 void Options::setRollOverDesktops(bool rollOverDesktops)
 {
     if (m_rollOverDesktops == rollOverDesktops) {
         return;
     }
     m_rollOverDesktops = rollOverDesktops;
     emit rollOverDesktopsChanged(m_rollOverDesktops);
 }
 
 void Options::setFocusStealingPreventionLevel(int focusStealingPreventionLevel)
 {
     if (!focusPolicyIsReasonable()) {
         focusStealingPreventionLevel = 0;
     }
     if (m_focusStealingPreventionLevel == focusStealingPreventionLevel) {
         return;
     }
     m_focusStealingPreventionLevel = qMax(0, qMin(4, focusStealingPreventionLevel));
     emit focusStealingPreventionLevelChanged();
 }
 
 void Options::setOperationTitlebarDblClick(WindowOperation operationTitlebarDblClick)
 {
     if (OpTitlebarDblClick == operationTitlebarDblClick) {
         return;
     }
     OpTitlebarDblClick = operationTitlebarDblClick;
     emit operationTitlebarDblClickChanged();
 }
 
 void Options::setOperationMaxButtonLeftClick(WindowOperation op)
 {
     if (opMaxButtonLeftClick == op) {
         return;
     }
     opMaxButtonLeftClick = op;
     emit operationMaxButtonLeftClickChanged();
 }
 
 void Options::setOperationMaxButtonRightClick(WindowOperation op)
 {
     if (opMaxButtonRightClick == op) {
         return;
     }
     opMaxButtonRightClick = op;
     emit operationMaxButtonRightClickChanged();
 }
 
 void Options::setOperationMaxButtonMiddleClick(WindowOperation op)
 {
     if (opMaxButtonMiddleClick == op) {
         return;
     }
     opMaxButtonMiddleClick = op;
     emit operationMaxButtonMiddleClickChanged();
 }
 
 void Options::setCommandActiveTitlebar1(MouseCommand commandActiveTitlebar1)
 {
     if (CmdActiveTitlebar1 == commandActiveTitlebar1) {
         return;
     }
     CmdActiveTitlebar1 = commandActiveTitlebar1;
     emit commandActiveTitlebar1Changed();
 }
 
 void Options::setCommandActiveTitlebar2(MouseCommand commandActiveTitlebar2)
 {
     if (CmdActiveTitlebar2 == commandActiveTitlebar2) {
         return;
     }
     CmdActiveTitlebar2 = commandActiveTitlebar2;
     emit commandActiveTitlebar2Changed();
 }
 
 void Options::setCommandActiveTitlebar3(MouseCommand commandActiveTitlebar3)
 {
     if (CmdActiveTitlebar3 == commandActiveTitlebar3) {
         return;
     }
     CmdActiveTitlebar3 = commandActiveTitlebar3;
     emit commandActiveTitlebar3Changed();
 }
 
 void Options::setCommandInactiveTitlebar1(MouseCommand commandInactiveTitlebar1)
 {
     if (CmdInactiveTitlebar1 == commandInactiveTitlebar1) {
         return;
     }
     CmdInactiveTitlebar1 = commandInactiveTitlebar1;
     emit commandInactiveTitlebar1Changed();
 }
 
 void Options::setCommandInactiveTitlebar2(MouseCommand commandInactiveTitlebar2)
 {
     if (CmdInactiveTitlebar2 == commandInactiveTitlebar2) {
         return;
     }
     CmdInactiveTitlebar2 = commandInactiveTitlebar2;
     emit commandInactiveTitlebar2Changed();
 }
 
 void Options::setCommandInactiveTitlebar3(MouseCommand commandInactiveTitlebar3)
 {
     if (CmdInactiveTitlebar3 == commandInactiveTitlebar3) {
         return;
     }
     CmdInactiveTitlebar3 = commandInactiveTitlebar3;
     emit commandInactiveTitlebar3Changed();
 }
 
 void Options::setCommandWindow1(MouseCommand commandWindow1)
 {
     if (CmdWindow1 == commandWindow1) {
         return;
     }
     CmdWindow1 = commandWindow1;
     emit commandWindow1Changed();
 }
 
 void Options::setCommandWindow2(MouseCommand commandWindow2)
 {
     if (CmdWindow2 == commandWindow2) {
         return;
     }
     CmdWindow2 = commandWindow2;
     emit commandWindow2Changed();
 }
 
 void Options::setCommandWindow3(MouseCommand commandWindow3)
 {
     if (CmdWindow3 == commandWindow3) {
         return;
     }
     CmdWindow3 = commandWindow3;
     emit commandWindow3Changed();
 }
 
 void Options::setCommandWindowWheel(MouseCommand commandWindowWheel)
 {
     if (CmdWindowWheel == commandWindowWheel) {
         return;
     }
     CmdWindowWheel = commandWindowWheel;
     emit commandWindowWheelChanged();
 }
 
 void Options::setCommandAll1(MouseCommand commandAll1)
 {
     if (CmdAll1 == commandAll1) {
         return;
     }
     CmdAll1 = commandAll1;
     emit commandAll1Changed();
 }
 
 void Options::setCommandAll2(MouseCommand commandAll2)
 {
     if (CmdAll2 == commandAll2) {
         return;
     }
     CmdAll2 = commandAll2;
     emit commandAll2Changed();
 }
 
 void Options::setCommandAll3(MouseCommand commandAll3)
 {
     if (CmdAll3 == commandAll3) {
         return;
     }
     CmdAll3 = commandAll3;
     emit commandAll3Changed();
 }
 
 void Options::setKeyCmdAllModKey(uint keyCmdAllModKey)
 {
     if (CmdAllModKey == keyCmdAllModKey) {
         return;
     }
     CmdAllModKey = keyCmdAllModKey;
     emit keyCmdAllModKeyChanged();
 }
 
 void Options::setShowGeometryTip(bool showGeometryTip)
 {
     if (show_geometry_tip == showGeometryTip) {
         return;
     }
     show_geometry_tip = showGeometryTip;
     emit showGeometryTipChanged();
 }
 
 void Options::setCondensedTitle(bool condensedTitle)
 {
     if (condensed_title == condensedTitle) {
         return;
     }
     condensed_title = condensedTitle;
     emit condensedTitleChanged();
 }
 
 void Options::setElectricBorderMaximize(bool electricBorderMaximize)
 {
     if (electric_border_maximize == electricBorderMaximize) {
         return;
     }
     electric_border_maximize = electricBorderMaximize;
     emit electricBorderMaximizeChanged();
 }
 
 void Options::setElectricBorderTiling(bool electricBorderTiling)
 {
     if (electric_border_tiling == electricBorderTiling) {
         return;
     }
     electric_border_tiling = electricBorderTiling;
     emit electricBorderTilingChanged();
 }
 
 void Options::setElectricBorderCornerRatio(float electricBorderCornerRatio)
 {
     if (electric_border_corner_ratio == electricBorderCornerRatio) {
         return;
     }
     electric_border_corner_ratio = electricBorderCornerRatio;
     emit electricBorderCornerRatioChanged();
 }
 
 void Options::setBorderlessMaximizedWindows(bool borderlessMaximizedWindows)
 {
     if (borderless_maximized_windows == borderlessMaximizedWindows) {
         return;
     }
     borderless_maximized_windows = borderlessMaximizedWindows;
     emit borderlessMaximizedWindowsChanged();
 }
 
 void Options::setKillPingTimeout(int killPingTimeout)
 {
     if (m_killPingTimeout == killPingTimeout) {
         return;
     }
     m_killPingTimeout = killPingTimeout;
     emit killPingTimeoutChanged();
 }
 
 void Options::setHideUtilityWindowsForInactive(bool hideUtilityWindowsForInactive)
 {
     if (m_hideUtilityWindowsForInactive == hideUtilityWindowsForInactive) {
         return;
     }
     m_hideUtilityWindowsForInactive = hideUtilityWindowsForInactive;
     emit hideUtilityWindowsForInactiveChanged();
 }
 
 void Options::setCompositingMode(int compositingMode)
 {
     if (m_compositingMode == static_cast<CompositingType>(compositingMode)) {
         return;
     }
     m_compositingMode = static_cast<CompositingType>(compositingMode);
     emit compositingModeChanged();
 }
 
 void Options::setUseCompositing(bool useCompositing)
 {
     if (m_useCompositing == useCompositing) {
         return;
     }
     m_useCompositing = useCompositing;
     emit useCompositingChanged();
 }
 
 void Options::setHiddenPreviews(int hiddenPreviews)
 {
     if (m_hiddenPreviews == static_cast<HiddenPreviews>(hiddenPreviews)) {
         return;
     }
     m_hiddenPreviews = static_cast<HiddenPreviews>(hiddenPreviews);
     emit hiddenPreviewsChanged();
 }
 
 void Options::setGlSmoothScale(int glSmoothScale)
 {
     if (m_glSmoothScale == glSmoothScale) {
         return;
     }
     m_glSmoothScale = glSmoothScale;
     emit glSmoothScaleChanged();
 }
 
 void Options::setXrenderSmoothScale(bool xrenderSmoothScale)
 {
     if (m_xrenderSmoothScale == xrenderSmoothScale) {
         return;
     }
     m_xrenderSmoothScale = xrenderSmoothScale;
     emit xrenderSmoothScaleChanged();
 }
 
 void Options::setMaxFpsInterval(qint64 maxFpsInterval)
 {
     if (m_maxFpsInterval == maxFpsInterval) {
         return;
     }
     m_maxFpsInterval = maxFpsInterval;
     emit maxFpsIntervalChanged();
 }
 
 void Options::setRefreshRate(uint refreshRate)
 {
     if (m_refreshRate == refreshRate) {
         return;
     }
     m_refreshRate = refreshRate;
     emit refreshRateChanged();
 }
 
 void Options::setVBlankTime(qint64 vBlankTime)
 {
     if (m_vBlankTime == vBlankTime) {
         return;
     }
     m_vBlankTime = vBlankTime;
     emit vBlankTimeChanged();
 }
 
 void Options::setGlStrictBinding(bool glStrictBinding)
 {
     if (m_glStrictBinding == glStrictBinding) {
         return;
     }
     m_glStrictBinding = glStrictBinding;
     emit glStrictBindingChanged();
 }
 
 void Options::setGlStrictBindingFollowsDriver(bool glStrictBindingFollowsDriver)
 {
     if (m_glStrictBindingFollowsDriver == glStrictBindingFollowsDriver) {
         return;
     }
     m_glStrictBindingFollowsDriver = glStrictBindingFollowsDriver;
     emit glStrictBindingFollowsDriverChanged();
 }
 
 void Options::setGLCoreProfile(bool value)
 {
     if (m_glCoreProfile == value) {
         return;
     }
     m_glCoreProfile = value;
     emit glCoreProfileChanged();
 }
 
 void Options::setWindowsBlockCompositing(bool value)
 {
     if (m_windowsBlockCompositing == value) {
         return;
     }
     m_windowsBlockCompositing = value;
     emit windowsBlockCompositingChanged();
 }
 
 void Options::setGlPreferBufferSwap(char glPreferBufferSwap)
 {
     if (glPreferBufferSwap == 'a') {
         // buffer cpying is very fast with the nvidia blob
         // but due to restrictions in DRI2 *incredibly* slow for all MESA drivers
         // see http://www.x.org/releases/X11R7.7/doc/dri2proto/dri2proto.txt, item 2.5
         if (GLPlatform::instance()->driver() == Driver_NVidia)
             glPreferBufferSwap = CopyFrontBuffer;
         else if (GLPlatform::instance()->driver() != Driver_Unknown) // undetected, finally resolved when context is initialized
             glPreferBufferSwap = ExtendDamage;
     }
     if (m_glPreferBufferSwap == (GlSwapStrategy)glPreferBufferSwap) {
         return;
     }
     m_glPreferBufferSwap = (GlSwapStrategy)glPreferBufferSwap;
     emit glPreferBufferSwapChanged();
 }
 
 void Options::setGlPlatformInterface(OpenGLPlatformInterface interface)
 {
     // check environment variable
     const QByteArray envOpenGLInterface(qgetenv("KWIN_OPENGL_INTERFACE"));
     if (!envOpenGLInterface.isEmpty()) {
         if (qstrcmp(envOpenGLInterface, "egl") == 0) {
             qCDebug(KWIN_CORE) << "Forcing EGL native interface through environment variable";
             interface = EglPlatformInterface;
         } else if (qstrcmp(envOpenGLInterface, "glx") == 0) {
             qCDebug(KWIN_CORE) << "Forcing GLX native interface through environment variable";
             interface = GlxPlatformInterface;
         }
     }
     if (kwinApp()->shouldUseWaylandForCompositing() && interface == GlxPlatformInterface) {
         // Glx is impossible on Wayland, enforce egl
         qCDebug(KWIN_CORE) << "Forcing EGL native interface for Wayland mode";
         interface = EglPlatformInterface;
     }
 #if !HAVE_EPOXY_GLX
     qCDebug(KWIN_CORE) << "Forcing EGL native interface as compiled without GLX support";
     interface = EglPlatformInterface;
 #endif
     if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES) {
         qCDebug(KWIN_CORE) << "Forcing EGL native interface as Qt uses OpenGL ES";
         interface = EglPlatformInterface;
     } else if (qstrcmp(qgetenv("KWIN_COMPOSE"), "O2ES") == 0) {
         qCDebug(KWIN_CORE) << "Forcing EGL native interface as OpenGL ES requested through KWIN_COMPOSE environment variable.";
         interface = EglPlatformInterface;
     }
 
     if (m_glPlatformInterface == interface) {
         return;
     }
     m_glPlatformInterface = interface;
     emit glPlatformInterfaceChanged();
 }
 
 void Options::reparseConfiguration()
 {
     m_settings->config()->reparseConfiguration();
 }
 
 void Options::updateSettings()
 {
     loadConfig();
     // Read button tooltip animation effect from kdeglobals
     // Since we want to allow users to enable window decoration tooltips
     // and not kstyle tooltips and vise-versa, we don't read the
     // "EffectNoTooltip" setting from kdeglobals.
 
 
 //    QToolTip::setGloballyEnabled( d->show_tooltips );
 // KDE4 this probably needs to be done manually in clients
 
     // Driver-specific config detection
     reloadCompositingSettings();
 
     emit configChanged();
 }
 
 void Options::loadConfig()
 {
     m_settings->load();
 
     syncFromKcfgc();
 
     // Electric borders
     KConfigGroup config(m_settings->config(), "Windows");
     OpTitlebarDblClick = windowOperation(config.readEntry("TitlebarDoubleClickCommand", "Maximize"), true);
     setOperationMaxButtonLeftClick(windowOperation(config.readEntry("MaximizeButtonLeftClickCommand", "Maximize"), true));
     setOperationMaxButtonMiddleClick(windowOperation(config.readEntry("MaximizeButtonMiddleClickCommand", "Maximize (vertical only)"), true));
     setOperationMaxButtonRightClick(windowOperation(config.readEntry("MaximizeButtonRightClickCommand", "Maximize (horizontal only)"), true));
 
     // Mouse bindings
     config = KConfigGroup(m_settings->config(), "MouseBindings");
     // TODO: add properties for missing options
     CmdTitlebarWheel = mouseWheelCommand(config.readEntry("CommandTitlebarWheel", "Nothing"));
     CmdAllModKey = (config.readEntry("CommandAllKey", "Alt") == QStringLiteral("Meta")) ? Qt::Key_Meta : Qt::Key_Alt;
     CmdAllWheel = mouseWheelCommand(config.readEntry("CommandAllWheel", "Nothing"));
     setCommandActiveTitlebar1(mouseCommand(config.readEntry("CommandActiveTitlebar1", "Raise"), true));
     setCommandActiveTitlebar2(mouseCommand(config.readEntry("CommandActiveTitlebar2", "Nothing"), true));
     setCommandActiveTitlebar3(mouseCommand(config.readEntry("CommandActiveTitlebar3", "Operations menu"), true));
     setCommandInactiveTitlebar1(mouseCommand(config.readEntry("CommandInactiveTitlebar1", "Activate and raise"), true));
     setCommandInactiveTitlebar2(mouseCommand(config.readEntry("CommandInactiveTitlebar2", "Nothing"), true));
     setCommandInactiveTitlebar3(mouseCommand(config.readEntry("CommandInactiveTitlebar3", "Operations menu"), true));
     setCommandWindow1(mouseCommand(config.readEntry("CommandWindow1", "Activate, raise and pass click"), false));
     setCommandWindow2(mouseCommand(config.readEntry("CommandWindow2", "Activate and pass click"), false));
     setCommandWindow3(mouseCommand(config.readEntry("CommandWindow3", "Activate and pass click"), false));
     setCommandWindowWheel(mouseCommand(config.readEntry("CommandWindowWheel", "Scroll"), false));
     setCommandAll1(mouseCommand(config.readEntry("CommandAll1", "Move"), false));
     setCommandAll2(mouseCommand(config.readEntry("CommandAll2", "Toggle raise and lower"), false));
     setCommandAll3(mouseCommand(config.readEntry("CommandAll3", "Resize"), false));
 
     // TODO: should they be moved into reloadCompositingSettings?
     config = KConfigGroup(m_settings->config(), "Compositing");
     setMaxFpsInterval(1 * 1000 * 1000 * 1000 / config.readEntry("MaxFPS", Options::defaultMaxFps()));
     setRefreshRate(config.readEntry("RefreshRate", Options::defaultRefreshRate()));
     setVBlankTime(config.readEntry("VBlankTime", Options::defaultVBlankTime()) * 1000); // config in micro, value in nano resolution
 
     // Modifier Only Shortcuts
     config = KConfigGroup(m_settings->config(), "ModifierOnlyShortcuts");
     m_modifierOnlyShortcuts.clear();
     if (config.hasKey("Shift")) {
         m_modifierOnlyShortcuts.insert(Qt::ShiftModifier, config.readEntry("Shift", QStringList()));
     }
     if (config.hasKey("Control")) {
         m_modifierOnlyShortcuts.insert(Qt::ControlModifier, config.readEntry("Control", QStringList()));
     }
     if (config.hasKey("Alt")) {
         m_modifierOnlyShortcuts.insert(Qt::AltModifier, config.readEntry("Alt", QStringList()));
     }
     m_modifierOnlyShortcuts.insert(Qt::MetaModifier, config.readEntry("Meta", QStringList{QStringLiteral("org.kde.plasmashell"),
                                                                                           QStringLiteral("/PlasmaShell"),
                                                                                           QStringLiteral("org.kde.PlasmaShell"),
                                                                                           QStringLiteral("activateLauncherMenu")}));
 }
 
 void Options::syncFromKcfgc()
 {
     setShowGeometryTip(m_settings->geometryTip());
     setCondensedTitle(m_settings->condensedTitle());
     setFocusPolicy(m_settings->focusPolicy());
     setNextFocusPrefersMouse(m_settings->nextFocusPrefersMouse());
     setSeparateScreenFocus(m_settings->separateScreenFocus());
     setRollOverDesktops(m_settings->rollOverDesktops());
     setFocusStealingPreventionLevel(m_settings->focusStealingPreventionLevel());
 
 #ifdef KWIN_BUILD_DECORATIONS
     setPlacement(m_settings->placement());
 #else
     setPlacement(Placement::Maximizing);
 #endif
 
     setAutoRaise(m_settings->autoRaise());
     setAutoRaiseInterval(m_settings->autoRaiseInterval());
     setDelayFocusInterval(m_settings->delayFocusInterval());
     setShadeHover(m_settings->shadeHover());
     setShadeHoverInterval(m_settings->shadeHoverInterval());
     setClickRaise(m_settings->clickRaise());
     setBorderSnapZone(m_settings->borderSnapZone());
     setWindowSnapZone(m_settings->windowSnapZone());
     setCenterSnapZone(m_settings->centerSnapZone());
     setSnapOnlyWhenOverlapping(m_settings->snapOnlyWhenOverlapping());
     setKillPingTimeout(m_settings->killPingTimeout());
     setHideUtilityWindowsForInactive(m_settings->hideUtilityWindowsForInactive());
     setBorderlessMaximizedWindows(m_settings->borderlessMaximizedWindows());
     setElectricBorderMaximize(m_settings->electricBorderMaximize());
     setElectricBorderTiling(m_settings->electricBorderTiling());
     setElectricBorderCornerRatio(m_settings->electricBorderCornerRatio());
     setWindowsBlockCompositing(m_settings->windowsBlockCompositing());
 
 }
 
 bool Options::loadCompositingConfig (bool force)
 {
     KConfigGroup config(m_settings->config(), "Compositing");
 
     bool useCompositing = false;
     CompositingType compositingMode = NoCompositing;
     QString compositingBackend = config.readEntry("Backend", "OpenGL");
     if (compositingBackend == QStringLiteral("XRender"))
         compositingMode = XRenderCompositing;
     else if (compositingBackend == "QPainter")
         compositingMode = QPainterCompositing;
     else
         compositingMode = OpenGLCompositing;
 
     if (const char *c = getenv("KWIN_COMPOSE")) {
         switch(c[0]) {
         case 'O':
             qCDebug(KWIN_CORE) << "Compositing forced to OpenGL mode by environment variable";
             compositingMode = OpenGLCompositing;
             useCompositing = true;
             break;
         case 'X':
             qCDebug(KWIN_CORE) << "Compositing forced to XRender mode by environment variable";
             compositingMode = XRenderCompositing;
             useCompositing = true;
             break;
         case 'Q':
             qCDebug(KWIN_CORE) << "Compositing forced to QPainter mode by environment variable";
             compositingMode = QPainterCompositing;
             useCompositing = true;
             break;
         case 'N':
             if (getenv("KDE_FAILSAFE"))
                 qCDebug(KWIN_CORE) << "Compositing disabled forcefully by KDE failsafe mode";
             else
                 qCDebug(KWIN_CORE) << "Compositing disabled forcefully by environment variable";
             compositingMode = NoCompositing;
             break;
         default:
             qCDebug(KWIN_CORE) << "Unknown KWIN_COMPOSE mode set, ignoring";
             break;
         }
     }
     setCompositingMode(compositingMode);
 
     const bool platformSupportsNoCompositing = kwinApp()->platform()->supportedCompositors().contains(NoCompositing);
     if (m_compositingMode == NoCompositing && platformSupportsNoCompositing) {
         setUseCompositing(false);
         return false; // do not even detect compositing preferences if explicitly disabled
     }
 
     // it's either enforced by env or by initial resume from "suspend" or we check the settings
     setUseCompositing(useCompositing || force || config.readEntry("Enabled", Options::defaultUseCompositing() || !platformSupportsNoCompositing));
 
     if (!m_useCompositing)
         return false; // not enforced or necessary and not "enabled" by settings
     return true;
 }
 
 void Options::reloadCompositingSettings(bool force)
 {
     if (!loadCompositingConfig(force)) {
         return;
     }
     m_settings->load();
     syncFromKcfgc();
 
     // Compositing settings
     KConfigGroup config(m_settings->config(), "Compositing");
 
     setGlSmoothScale(qBound(-1, config.readEntry("GLTextureFilter", Options::defaultGlSmoothScale()), 2));
     setGlStrictBindingFollowsDriver(!config.hasKey("GLStrictBinding"));
     if (!isGlStrictBindingFollowsDriver()) {
         setGlStrictBinding(config.readEntry("GLStrictBinding", Options::defaultGlStrictBinding()));
     }
     setGLCoreProfile(config.readEntry("GLCore", Options::defaultGLCoreProfile()));
 
-    char c = 0;
+    char c = 'a';
     const QString s = config.readEntry("GLPreferBufferSwap", QString(Options::defaultGlPreferBufferSwap()));
     if (!s.isEmpty())
         c = s.at(0).toLatin1();
     if (c != 'a' && c != 'c' && c != 'p' && c != 'e')
-        c = 0;
+        c = 'a';
     setGlPreferBufferSwap(c);
 
     m_xrenderSmoothScale = config.readEntry("XRenderSmoothScale", false);
 
     HiddenPreviews previews = Options::defaultHiddenPreviews();
     // 4 - off, 5 - shown, 6 - always, other are old values
     int hps = config.readEntry("HiddenPreviews", 5);
     if (hps == 4)
         previews = HiddenPreviewsNever;
     else if (hps == 5)
         previews = HiddenPreviewsShown;
     else if (hps == 6)
         previews = HiddenPreviewsAlways;
     setHiddenPreviews(previews);
 
     auto interfaceToKey = [](OpenGLPlatformInterface interface) {
         switch (interface) {
         case GlxPlatformInterface:
             return QStringLiteral("glx");
         case EglPlatformInterface:
             return QStringLiteral("egl");
         default:
             return QString();
         }
     };
     auto keyToInterface = [](const QString &key) {
         if (key == QStringLiteral("glx")) {
             return GlxPlatformInterface;
         } else if (key == QStringLiteral("egl")) {
             return EglPlatformInterface;
         }
         return defaultGlPlatformInterface();
     };
     setGlPlatformInterface(keyToInterface(config.readEntry("GLPlatformInterface", interfaceToKey(m_glPlatformInterface))));
 }
 
 // restricted should be true for operations that the user may not be able to repeat
 // if the window is moved out of the workspace (e.g. if the user moves a window
 // by the titlebar, and moves it too high beneath Kicker at the top edge, they
 // may not be able to move it back, unless they know about Alt+LMB)
 Options::WindowOperation Options::windowOperation(const QString &name, bool restricted)
 {
     if (name == QStringLiteral("Move"))
         return restricted ? MoveOp : UnrestrictedMoveOp;
     else if (name == QStringLiteral("Resize"))
         return restricted ? ResizeOp : UnrestrictedResizeOp;
     else if (name == QStringLiteral("Maximize"))
         return MaximizeOp;
     else if (name == QStringLiteral("Minimize"))
         return MinimizeOp;
     else if (name == QStringLiteral("Close"))
         return CloseOp;
     else if (name == QStringLiteral("OnAllDesktops"))
         return OnAllDesktopsOp;
     else if (name == QStringLiteral("Shade"))
         return ShadeOp;
     else if (name == QStringLiteral("Operations"))
         return OperationsOp;
     else if (name == QStringLiteral("Maximize (vertical only)"))
         return VMaximizeOp;
     else if (name == QStringLiteral("Maximize (horizontal only)"))
         return HMaximizeOp;
     else if (name == QStringLiteral("Lower"))
         return LowerOp;
     return NoOp;
 }
 
 Options::MouseCommand Options::mouseCommand(const QString &name, bool restricted)
 {
     QString lowerName = name.toLower();
     if (lowerName == QStringLiteral("raise")) return MouseRaise;
     if (lowerName == QStringLiteral("lower")) return MouseLower;
     if (lowerName == QStringLiteral("operations menu")) return MouseOperationsMenu;
     if (lowerName == QStringLiteral("toggle raise and lower")) return MouseToggleRaiseAndLower;
     if (lowerName == QStringLiteral("activate and raise")) return MouseActivateAndRaise;
     if (lowerName == QStringLiteral("activate and lower")) return MouseActivateAndLower;
     if (lowerName == QStringLiteral("activate")) return MouseActivate;
     if (lowerName == QStringLiteral("activate, raise and pass click")) return MouseActivateRaiseAndPassClick;
     if (lowerName == QStringLiteral("activate and pass click")) return MouseActivateAndPassClick;
     if (lowerName == QStringLiteral("scroll")) return MouseNothing;
     if (lowerName == QStringLiteral("activate and scroll")) return MouseActivateAndPassClick;
     if (lowerName == QStringLiteral("activate, raise and scroll")) return MouseActivateRaiseAndPassClick;
     if (lowerName == QStringLiteral("activate, raise and move"))
         return restricted ? MouseActivateRaiseAndMove : MouseActivateRaiseAndUnrestrictedMove;
     if (lowerName == QStringLiteral("move")) return restricted ? MouseMove : MouseUnrestrictedMove;
     if (lowerName == QStringLiteral("resize")) return restricted ? MouseResize : MouseUnrestrictedResize;
     if (lowerName == QStringLiteral("shade")) return MouseShade;
     if (lowerName == QStringLiteral("minimize")) return MouseMinimize;
     if (lowerName == QStringLiteral("close")) return MouseClose;
     if (lowerName == QStringLiteral("increase opacity")) return MouseOpacityMore;
     if (lowerName == QStringLiteral("decrease opacity")) return MouseOpacityLess;
     if (lowerName == QStringLiteral("nothing")) return MouseNothing;
     return MouseNothing;
 }
 
 Options::MouseWheelCommand Options::mouseWheelCommand(const QString &name)
 {
     QString lowerName = name.toLower();
     if (lowerName == QStringLiteral("raise/lower")) return MouseWheelRaiseLower;
     if (lowerName == QStringLiteral("shade/unshade")) return MouseWheelShadeUnshade;
     if (lowerName == QStringLiteral("maximize/restore")) return MouseWheelMaximizeRestore;
     if (lowerName == QStringLiteral("above/below")) return MouseWheelAboveBelow;
     if (lowerName == QStringLiteral("previous/next desktop")) return MouseWheelPreviousNextDesktop;
     if (lowerName == QStringLiteral("change opacity")) return MouseWheelChangeOpacity;
     if (lowerName == QStringLiteral("nothing")) return MouseWheelNothing;
     return MouseWheelNothing;
 }
 
 bool Options::showGeometryTip() const
 {
     return show_geometry_tip;
 }
 
 bool Options::condensedTitle() const
 {
     return condensed_title;
 }
 
 Options::MouseCommand Options::wheelToMouseCommand(MouseWheelCommand com, int delta) const
 {
     switch(com) {
     case MouseWheelRaiseLower:
         return delta > 0 ? MouseRaise : MouseLower;
     case MouseWheelShadeUnshade:
         return delta > 0 ? MouseSetShade : MouseUnsetShade;
     case MouseWheelMaximizeRestore:
         return delta > 0 ? MouseMaximize : MouseRestore;
     case MouseWheelAboveBelow:
         return delta > 0 ? MouseAbove : MouseBelow;
     case MouseWheelPreviousNextDesktop:
         return delta > 0 ? MousePreviousDesktop : MouseNextDesktop;
     case MouseWheelChangeOpacity:
         return delta > 0 ? MouseOpacityMore : MouseOpacityLess;
     default:
         return MouseNothing;
     }
 }
 #endif
 
 double Options::animationTimeFactor() const
 {
  #ifndef KCMRULES
     return m_settings->animationDurationFactor();
 #else
     return 0;
 #endif
 }
 
 Options::WindowOperation Options::operationMaxButtonClick(Qt::MouseButtons button) const
 {
     return button == Qt::RightButton ? opMaxButtonRightClick :
            button == Qt::MidButton ?   opMaxButtonMiddleClick :
            opMaxButtonLeftClick;
 }
 
 QStringList Options::modifierOnlyDBusShortcut(Qt::KeyboardModifier mod) const
 {
     return m_modifierOnlyShortcuts.value(mod);
 }
 
 bool Options::isUseCompositing() const
 {
     return m_useCompositing || kwinApp()->platform()->requiresCompositing();
 }
 
 } // namespace
diff --git a/options.h b/options.h
index ee31cfea9..8f28f1df8 100644
--- a/options.h
+++ b/options.h
@@ -1,905 +1,905 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2012 Martin Gräßlin <m.graesslin@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_OPTIONS_H
 #define KWIN_OPTIONS_H
 
 #include "main.h"
 #include "placement.h"
 
 #include <KConfigWatcher>
 
 namespace KWin
 {
 
 // Whether to keep all windows mapped when compositing (i.e. whether to have
 // actively updated window pixmaps).
 enum HiddenPreviews {
     // The normal mode with regard to mapped windows. Hidden (minimized, etc.)
     // and windows on inactive virtual desktops are not mapped, their pixmaps
     // are only their icons.
     HiddenPreviewsNever,
     // Like normal mode, but shown windows (i.e. on inactive virtual desktops)
     // are kept mapped, only hidden windows are unmapped.
     HiddenPreviewsShown,
     // All windows are kept mapped regardless of their state.
     HiddenPreviewsAlways
 };
 
 class Settings;
 
 class KWIN_EXPORT Options : public QObject
 {
     Q_OBJECT
     Q_ENUMS(FocusPolicy)
     Q_ENUMS(GlSwapStrategy)
     Q_ENUMS(MouseCommand)
     Q_ENUMS(MouseWheelCommand)
     Q_ENUMS(WindowOperation)
 
     Q_PROPERTY(FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy NOTIFY focusPolicyChanged)
     Q_PROPERTY(bool nextFocusPrefersMouse READ isNextFocusPrefersMouse WRITE setNextFocusPrefersMouse NOTIFY nextFocusPrefersMouseChanged)
     /**
      * Whether clicking on a window raises it in FocusFollowsMouse
      * mode or not.
      */
     Q_PROPERTY(bool clickRaise READ isClickRaise WRITE setClickRaise NOTIFY clickRaiseChanged)
     /**
      * Whether autoraise is enabled FocusFollowsMouse mode or not.
      */
     Q_PROPERTY(bool autoRaise READ isAutoRaise WRITE setAutoRaise NOTIFY autoRaiseChanged)
     /**
      * Autoraise interval.
      */
     Q_PROPERTY(int autoRaiseInterval READ autoRaiseInterval WRITE setAutoRaiseInterval NOTIFY autoRaiseIntervalChanged)
     /**
      * Delayed focus interval.
      */
     Q_PROPERTY(int delayFocusInterval READ delayFocusInterval WRITE setDelayFocusInterval NOTIFY delayFocusIntervalChanged)
     /**
      * Whether shade hover is enabled or not.
      */
     Q_PROPERTY(bool shadeHover READ isShadeHover WRITE setShadeHover NOTIFY shadeHoverChanged)
     /**
      * Shade hover interval.
      */
     Q_PROPERTY(int shadeHoverInterval READ shadeHoverInterval WRITE setShadeHoverInterval NOTIFY shadeHoverIntervalChanged)
     /**
      * Whether to see Xinerama screens separately for focus (in Alt+Tab, when activating next client)
      */
     Q_PROPERTY(bool separateScreenFocus READ isSeparateScreenFocus WRITE setSeparateScreenFocus NOTIFY separateScreenFocusChanged)
     Q_PROPERTY(int placement READ placement WRITE setPlacement NOTIFY placementChanged)
     Q_PROPERTY(bool focusPolicyIsReasonable READ focusPolicyIsReasonable NOTIFY focusPolicyIsResonableChanged)
     /**
      * The size of the zone that triggers snapping on desktop borders.
      */
     Q_PROPERTY(int borderSnapZone READ borderSnapZone WRITE setBorderSnapZone NOTIFY borderSnapZoneChanged)
     /**
      * The size of the zone that triggers snapping with other windows.
      */
     Q_PROPERTY(int windowSnapZone READ windowSnapZone WRITE setWindowSnapZone NOTIFY windowSnapZoneChanged)
     /**
      * The size of the zone that triggers snapping on the screen center.
      */
     Q_PROPERTY(int centerSnapZone READ centerSnapZone WRITE setCenterSnapZone NOTIFY centerSnapZoneChanged)
     /**
      * Snap only when windows will overlap.
      */
     Q_PROPERTY(bool snapOnlyWhenOverlapping READ isSnapOnlyWhenOverlapping WRITE setSnapOnlyWhenOverlapping NOTIFY snapOnlyWhenOverlappingChanged)
     /**
      * Whether or not we roll over to the other edge when switching desktops past the edge.
      */
     Q_PROPERTY(bool rollOverDesktops READ isRollOverDesktops WRITE setRollOverDesktops NOTIFY rollOverDesktopsChanged)
     /**
      * 0 - 4 , see Workspace::allowClientActivation()
      */
     Q_PROPERTY(int focusStealingPreventionLevel READ focusStealingPreventionLevel WRITE setFocusStealingPreventionLevel NOTIFY focusStealingPreventionLevelChanged)
     Q_PROPERTY(KWin::Options::WindowOperation operationTitlebarDblClick READ operationTitlebarDblClick WRITE setOperationTitlebarDblClick NOTIFY operationTitlebarDblClickChanged)
     Q_PROPERTY(KWin::Options::WindowOperation operationMaxButtonLeftClick READ operationMaxButtonLeftClick WRITE setOperationMaxButtonLeftClick NOTIFY operationMaxButtonLeftClickChanged)
     Q_PROPERTY(KWin::Options::WindowOperation operationMaxButtonMiddleClick READ operationMaxButtonMiddleClick WRITE setOperationMaxButtonMiddleClick NOTIFY operationMaxButtonMiddleClickChanged)
     Q_PROPERTY(KWin::Options::WindowOperation operationMaxButtonRightClick READ operationMaxButtonRightClick WRITE setOperationMaxButtonRightClick NOTIFY operationMaxButtonRightClickChanged)
     Q_PROPERTY(MouseCommand commandActiveTitlebar1 READ commandActiveTitlebar1 WRITE setCommandActiveTitlebar1 NOTIFY commandActiveTitlebar1Changed)
     Q_PROPERTY(MouseCommand commandActiveTitlebar2 READ commandActiveTitlebar2 WRITE setCommandActiveTitlebar2 NOTIFY commandActiveTitlebar2Changed)
     Q_PROPERTY(MouseCommand commandActiveTitlebar3 READ commandActiveTitlebar3 WRITE setCommandActiveTitlebar3 NOTIFY commandActiveTitlebar3Changed)
     Q_PROPERTY(MouseCommand commandInactiveTitlebar1 READ commandInactiveTitlebar1 WRITE setCommandInactiveTitlebar1 NOTIFY commandInactiveTitlebar1Changed)
     Q_PROPERTY(MouseCommand commandInactiveTitlebar2 READ commandInactiveTitlebar2 WRITE setCommandInactiveTitlebar2 NOTIFY commandInactiveTitlebar2Changed)
     Q_PROPERTY(MouseCommand commandInactiveTitlebar3 READ commandInactiveTitlebar3 WRITE setCommandInactiveTitlebar3 NOTIFY commandInactiveTitlebar3Changed)
     Q_PROPERTY(MouseCommand commandWindow1 READ commandWindow1 WRITE setCommandWindow1 NOTIFY commandWindow1Changed)
     Q_PROPERTY(MouseCommand commandWindow2 READ commandWindow2 WRITE setCommandWindow2 NOTIFY commandWindow2Changed)
     Q_PROPERTY(MouseCommand commandWindow3 READ commandWindow3 WRITE setCommandWindow3 NOTIFY commandWindow3Changed)
     Q_PROPERTY(MouseCommand commandWindowWheel READ commandWindowWheel WRITE setCommandWindowWheel NOTIFY commandWindowWheelChanged)
     Q_PROPERTY(MouseCommand commandAll1 READ commandAll1 WRITE setCommandAll1 NOTIFY commandAll1Changed)
     Q_PROPERTY(MouseCommand commandAll2 READ commandAll2 WRITE setCommandAll2 NOTIFY commandAll2Changed)
     Q_PROPERTY(MouseCommand commandAll3 READ commandAll3 WRITE setCommandAll3 NOTIFY commandAll3Changed)
     Q_PROPERTY(uint keyCmdAllModKey READ keyCmdAllModKey WRITE setKeyCmdAllModKey NOTIFY keyCmdAllModKeyChanged)
     /**
      * Whether the Geometry Tip should be shown during a window move/resize.
      */
     Q_PROPERTY(bool showGeometryTip READ showGeometryTip WRITE setShowGeometryTip NOTIFY showGeometryTipChanged)
     /**
      * Whether the visible name should be condensed.
      */
     Q_PROPERTY(bool condensedTitle READ condensedTitle WRITE setCondensedTitle NOTIFY condensedTitleChanged)
     /**
      * Whether a window gets maximized when it reaches top screen edge while being moved.
      */
     Q_PROPERTY(bool electricBorderMaximize READ electricBorderMaximize WRITE setElectricBorderMaximize NOTIFY electricBorderMaximizeChanged)
     /**
      * Whether a window is tiled to half screen when reaching left or right screen edge while been moved.
      */
     Q_PROPERTY(bool electricBorderTiling READ electricBorderTiling WRITE setElectricBorderTiling NOTIFY electricBorderTilingChanged)
     /**
      * Whether a window is tiled to half screen when reaching left or right screen edge while been moved.
      */
     Q_PROPERTY(float electricBorderCornerRatio READ electricBorderCornerRatio WRITE setElectricBorderCornerRatio NOTIFY electricBorderCornerRatioChanged)
     Q_PROPERTY(bool borderlessMaximizedWindows READ borderlessMaximizedWindows WRITE setBorderlessMaximizedWindows NOTIFY borderlessMaximizedWindowsChanged)
     /**
      * timeout before non-responding application will be killed after attempt to close.
      */
     Q_PROPERTY(int killPingTimeout READ killPingTimeout WRITE setKillPingTimeout NOTIFY killPingTimeoutChanged)
     /**
      * Whether to hide utility windows for inactive applications.
      */
     Q_PROPERTY(bool hideUtilityWindowsForInactive READ isHideUtilityWindowsForInactive WRITE setHideUtilityWindowsForInactive NOTIFY hideUtilityWindowsForInactiveChanged)
     Q_PROPERTY(int compositingMode READ compositingMode WRITE setCompositingMode NOTIFY compositingModeChanged)
     Q_PROPERTY(bool useCompositing READ isUseCompositing WRITE setUseCompositing NOTIFY useCompositingChanged)
     Q_PROPERTY(int hiddenPreviews READ hiddenPreviews WRITE setHiddenPreviews NOTIFY hiddenPreviewsChanged)
     /**
      * 0 = no, 1 = yes when transformed,
      * 2 = try trilinear when transformed; else 1,
      * -1 = auto
      */
     Q_PROPERTY(int glSmoothScale READ glSmoothScale WRITE setGlSmoothScale NOTIFY glSmoothScaleChanged)
     Q_PROPERTY(bool xrenderSmoothScale READ isXrenderSmoothScale WRITE setXrenderSmoothScale NOTIFY xrenderSmoothScaleChanged)
     Q_PROPERTY(qint64 maxFpsInterval READ maxFpsInterval WRITE setMaxFpsInterval NOTIFY maxFpsIntervalChanged)
     Q_PROPERTY(uint refreshRate READ refreshRate WRITE setRefreshRate NOTIFY refreshRateChanged)
     Q_PROPERTY(qint64 vBlankTime READ vBlankTime WRITE setVBlankTime NOTIFY vBlankTimeChanged)
     Q_PROPERTY(bool glStrictBinding READ isGlStrictBinding WRITE setGlStrictBinding NOTIFY glStrictBindingChanged)
     /**
      * Whether strict binding follows the driver or has been overwritten by a user defined config value.
      * If @c true glStrictBinding is set by the OpenGL Scene during initialization.
      * If @c false glStrictBinding is set from a config value and not updated during scene initialization.
      */
     Q_PROPERTY(bool glStrictBindingFollowsDriver READ isGlStrictBindingFollowsDriver WRITE setGlStrictBindingFollowsDriver NOTIFY glStrictBindingFollowsDriverChanged)
     Q_PROPERTY(bool glCoreProfile READ glCoreProfile WRITE setGLCoreProfile NOTIFY glCoreProfileChanged)
     Q_PROPERTY(GlSwapStrategy glPreferBufferSwap READ glPreferBufferSwap WRITE setGlPreferBufferSwap NOTIFY glPreferBufferSwapChanged)
     Q_PROPERTY(KWin::OpenGLPlatformInterface glPlatformInterface READ glPlatformInterface WRITE setGlPlatformInterface NOTIFY glPlatformInterfaceChanged)
     Q_PROPERTY(bool windowsBlockCompositing READ windowsBlockCompositing WRITE setWindowsBlockCompositing NOTIFY windowsBlockCompositingChanged)
 public:
 
     explicit Options(QObject *parent = nullptr);
     ~Options() override;
 
     void updateSettings();
 
     /**
      * This enum type is used to specify the focus policy.
      *
      * Note that FocusUnderMouse and FocusStrictlyUnderMouse are not
      * particulary useful. They are only provided for old-fashined
      * die-hard UNIX people ;-)
      */
     enum FocusPolicy {
         /**
          * Clicking into a window activates it. This is also the default.
          */
         ClickToFocus,
         /**
          * Moving the mouse pointer actively onto a normal window activates it.
          * For convenience, the desktop and windows on the dock are excluded.
          * They require clicking.
          */
         FocusFollowsMouse,
         /**
          * The window that happens to be under the mouse pointer becomes active.
          * The invariant is: no window can have focus that is not under the mouse.
          * This also means that Alt-Tab won't work properly and popup dialogs are
          * usually unsable with the keyboard. Note that the desktop and windows on
          * the dock are excluded for convenience. They get focus only when clicking
          * on it.
          */
         FocusUnderMouse,
         /**
          * This is even worse than FocusUnderMouse. Only the window under the mouse
          * pointer is active. If the mouse points nowhere, nothing has the focus. If
          * the mouse points onto the desktop, the desktop has focus. The same holds
          * for windows on the dock.
          */
         FocusStrictlyUnderMouse
     };
 
     FocusPolicy focusPolicy() const {
         return m_focusPolicy;
     }
     bool isNextFocusPrefersMouse() const {
         return m_nextFocusPrefersMouse;
     }
 
     /**
      * Whether clicking on a window raises it in FocusFollowsMouse
      * mode or not.
      */
     bool isClickRaise() const {
         return m_clickRaise;
     }
 
     /**
      * Whether autoraise is enabled FocusFollowsMouse mode or not.
      */
     bool isAutoRaise() const {
         return m_autoRaise;
     }
 
     /**
      * Autoraise interval
      */
     int autoRaiseInterval() const {
         return m_autoRaiseInterval;
     }
 
     /**
      * Delayed focus interval.
      */
     int delayFocusInterval() const {
         return m_delayFocusInterval;
     }
 
     /**
      * Whether shade hover is enabled or not.
      */
     bool isShadeHover() const {
         return m_shadeHover;
     }
 
     /**
      * Shade hover interval.
      */
     int shadeHoverInterval() {
         return m_shadeHoverInterval;
     }
 
     /**
      * Whether to see Xinerama screens separately for focus (in Alt+Tab, when activating next client)
      */
     bool isSeparateScreenFocus() const {
         return m_separateScreenFocus;
     }
 
     Placement::Policy placement() const {
         return m_placement;
     }
 
     bool focusPolicyIsReasonable() {
         return m_focusPolicy == ClickToFocus || m_focusPolicy == FocusFollowsMouse;
     }
 
     /**
      * The size of the zone that triggers snapping on desktop borders.
      */
     int borderSnapZone() const {
         return m_borderSnapZone;
     }
 
     /**
      * The size of the zone that triggers snapping with other windows.
      */
     int windowSnapZone() const {
         return m_windowSnapZone;
     }
 
     /**
      * The size of the zone that triggers snapping on the screen center.
      */
     int centerSnapZone() const {
         return m_centerSnapZone;
     }
 
 
     /**
      * Snap only when windows will overlap.
      */
     bool isSnapOnlyWhenOverlapping() const {
         return m_snapOnlyWhenOverlapping;
     }
 
     /**
      * Whether or not we roll over to the other edge when switching desktops past the edge.
      */
     bool isRollOverDesktops() const {
         return m_rollOverDesktops;
     }
 
     /**
      * Returns the focus stealing prevention level.
      *
      * @see allowClientActivation
      */
     int focusStealingPreventionLevel() const {
         return m_focusStealingPreventionLevel;
     }
 
     enum WindowOperation {
         MaximizeOp = 5000,
         RestoreOp,
         MinimizeOp,
         MoveOp,
         UnrestrictedMoveOp,
         ResizeOp,
         UnrestrictedResizeOp,
         CloseOp,
         OnAllDesktopsOp,
         ShadeOp,
         KeepAboveOp,
         KeepBelowOp,
         OperationsOp,
         WindowRulesOp,
         ToggleStoreSettingsOp = WindowRulesOp, ///< @obsolete
         HMaximizeOp,
         VMaximizeOp,
         LowerOp,
         FullScreenOp,
         NoBorderOp,
         NoOp,
         SetupWindowShortcutOp,
         ApplicationRulesOp,
     };
 
     WindowOperation operationTitlebarDblClick() const {
         return OpTitlebarDblClick;
     }
     WindowOperation operationMaxButtonLeftClick() const {
         return opMaxButtonLeftClick;
     }
     WindowOperation operationMaxButtonRightClick() const {
         return opMaxButtonRightClick;
     }
     WindowOperation operationMaxButtonMiddleClick() const {
         return opMaxButtonMiddleClick;
     }
     WindowOperation operationMaxButtonClick(Qt::MouseButtons button) const;
 
 
     enum MouseCommand {
         MouseRaise, MouseLower, MouseOperationsMenu, MouseToggleRaiseAndLower,
         MouseActivateAndRaise, MouseActivateAndLower, MouseActivate,
         MouseActivateRaiseAndPassClick, MouseActivateAndPassClick,
         MouseMove, MouseUnrestrictedMove,
         MouseActivateRaiseAndMove, MouseActivateRaiseAndUnrestrictedMove,
         MouseResize, MouseUnrestrictedResize,
         MouseShade, MouseSetShade, MouseUnsetShade,
         MouseMaximize, MouseRestore, MouseMinimize,
         MouseNextDesktop, MousePreviousDesktop,
         MouseAbove, MouseBelow,
         MouseOpacityMore, MouseOpacityLess,
         MouseClose,
         MouseNothing
     };
 
     enum MouseWheelCommand {
         MouseWheelRaiseLower, MouseWheelShadeUnshade, MouseWheelMaximizeRestore,
         MouseWheelAboveBelow, MouseWheelPreviousNextDesktop,
         MouseWheelChangeOpacity,
         MouseWheelNothing
     };
 
     MouseCommand operationTitlebarMouseWheel(int delta) const {
         return wheelToMouseCommand(CmdTitlebarWheel, delta);
     }
     MouseCommand operationWindowMouseWheel(int delta) const {
         return wheelToMouseCommand(CmdAllWheel, delta);
     }
 
     MouseCommand commandActiveTitlebar1() const {
         return CmdActiveTitlebar1;
     }
     MouseCommand commandActiveTitlebar2() const {
         return CmdActiveTitlebar2;
     }
     MouseCommand commandActiveTitlebar3() const {
         return CmdActiveTitlebar3;
     }
     MouseCommand commandInactiveTitlebar1() const {
         return CmdInactiveTitlebar1;
     }
     MouseCommand commandInactiveTitlebar2() const {
         return CmdInactiveTitlebar2;
     }
     MouseCommand commandInactiveTitlebar3() const {
         return CmdInactiveTitlebar3;
     }
     MouseCommand commandWindow1() const {
         return CmdWindow1;
     }
     MouseCommand commandWindow2() const {
         return CmdWindow2;
     }
     MouseCommand commandWindow3() const {
         return CmdWindow3;
     }
     MouseCommand commandWindowWheel() const {
         return CmdWindowWheel;
     }
     MouseCommand commandAll1() const {
         return CmdAll1;
     }
     MouseCommand commandAll2() const {
         return CmdAll2;
     }
     MouseCommand commandAll3() const {
         return CmdAll3;
     }
     uint keyCmdAllModKey() const {
         return CmdAllModKey;
     }
     Qt::KeyboardModifier commandAllModifier() const {
         switch (CmdAllModKey) {
         case Qt::Key_Alt:
             return Qt::AltModifier;
         case Qt::Key_Meta:
             return Qt::MetaModifier;
         default:
             Q_UNREACHABLE();
         }
     }
 
     static WindowOperation windowOperation(const QString &name, bool restricted);
     static MouseCommand mouseCommand(const QString &name, bool restricted);
     static MouseWheelCommand mouseWheelCommand(const QString &name);
 
     /**
      * @returns true if the Geometry Tip should be shown during a window move/resize.
      */
     bool showGeometryTip() const;
 
     /**
      * Returns whether the user prefers his caption clean.
      */
     bool condensedTitle() const;
 
     /**
      * @returns true if a window gets maximized when it reaches top screen edge
      * while being moved.
      */
     bool electricBorderMaximize() const {
         return electric_border_maximize;
     }
     /**
      * @returns true if window is tiled to half screen when reaching left or
      * right screen edge while been moved.
      */
     bool electricBorderTiling() const {
         return electric_border_tiling;
     }
     /**
      * @returns the factor that determines the corner part of the edge (ie. 0.1 means tiny corner)
      */
     float electricBorderCornerRatio() const {
         return electric_border_corner_ratio;
     }
 
     bool borderlessMaximizedWindows() const {
         return borderless_maximized_windows;
     }
 
     /**
      * Timeout before non-responding application will be killed after attempt to close.
      */
     int killPingTimeout() const {
         return m_killPingTimeout;
     }
 
     /**
      * Whether to hide utility windows for inactive applications.
      */
     bool isHideUtilityWindowsForInactive() const {
         return m_hideUtilityWindowsForInactive;
     }
 
     /**
      * Returns the animation time factor for desktop effects.
      */
     double animationTimeFactor() const;
 
     //----------------------
     // Compositing settings
     void reloadCompositingSettings(bool force = false);
     CompositingType compositingMode() const {
         return m_compositingMode;
     }
     void setCompositingMode(CompositingType mode) {
         m_compositingMode = mode;
     }
     // Separate to mode so the user can toggle
     bool isUseCompositing() const;
 
     // General preferences
     HiddenPreviews hiddenPreviews() const {
         return m_hiddenPreviews;
     }
     // OpenGL
     // 0 = no, 1 = yes when transformed,
     // 2 = try trilinear when transformed; else 1,
     // -1 = auto
     int glSmoothScale() const {
         return m_glSmoothScale;
     }
     // XRender
     bool isXrenderSmoothScale() const {
         return m_xrenderSmoothScale;
     }
 
     qint64 maxFpsInterval() const {
         return m_maxFpsInterval;
     }
     // Settings that should be auto-detected
     uint refreshRate() const {
         return m_refreshRate;
     }
     qint64 vBlankTime() const {
         return m_vBlankTime;
     }
     bool isGlStrictBinding() const {
         return m_glStrictBinding;
     }
     bool isGlStrictBindingFollowsDriver() const {
         return m_glStrictBindingFollowsDriver;
     }
     bool glCoreProfile() const {
         return m_glCoreProfile;
     }
     OpenGLPlatformInterface glPlatformInterface() const {
         return m_glPlatformInterface;
     }
 
-    enum GlSwapStrategy { NoSwapEncourage = 0, CopyFrontBuffer = 'c', PaintFullScreen = 'p', ExtendDamage = 'e', AutoSwapStrategy = 'a' };
+    enum GlSwapStrategy { CopyFrontBuffer = 'c', PaintFullScreen = 'p', ExtendDamage = 'e', AutoSwapStrategy = 'a' };
     GlSwapStrategy glPreferBufferSwap() const {
         return m_glPreferBufferSwap;
     }
 
     bool windowsBlockCompositing() const
     {
         return m_windowsBlockCompositing;
     }
 
     QStringList modifierOnlyDBusShortcut(Qt::KeyboardModifier mod) const;
 
     // setters
     void setFocusPolicy(FocusPolicy focusPolicy);
     void setNextFocusPrefersMouse(bool nextFocusPrefersMouse);
     void setClickRaise(bool clickRaise);
     void setAutoRaise(bool autoRaise);
     void setAutoRaiseInterval(int autoRaiseInterval);
     void setDelayFocusInterval(int delayFocusInterval);
     void setShadeHover(bool shadeHover);
     void setShadeHoverInterval(int shadeHoverInterval);
     void setSeparateScreenFocus(bool separateScreenFocus);
     void setPlacement(int placement);
     void setBorderSnapZone(int borderSnapZone);
     void setWindowSnapZone(int windowSnapZone);
     void setCenterSnapZone(int centerSnapZone);
     void setSnapOnlyWhenOverlapping(bool snapOnlyWhenOverlapping);
     void setRollOverDesktops(bool rollOverDesktops);
     void setFocusStealingPreventionLevel(int focusStealingPreventionLevel);
     void setOperationTitlebarDblClick(WindowOperation operationTitlebarDblClick);
     void setOperationMaxButtonLeftClick(WindowOperation op);
     void setOperationMaxButtonRightClick(WindowOperation op);
     void setOperationMaxButtonMiddleClick(WindowOperation op);
     void setCommandActiveTitlebar1(MouseCommand commandActiveTitlebar1);
     void setCommandActiveTitlebar2(MouseCommand commandActiveTitlebar2);
     void setCommandActiveTitlebar3(MouseCommand commandActiveTitlebar3);
     void setCommandInactiveTitlebar1(MouseCommand commandInactiveTitlebar1);
     void setCommandInactiveTitlebar2(MouseCommand commandInactiveTitlebar2);
     void setCommandInactiveTitlebar3(MouseCommand commandInactiveTitlebar3);
     void setCommandWindow1(MouseCommand commandWindow1);
     void setCommandWindow2(MouseCommand commandWindow2);
     void setCommandWindow3(MouseCommand commandWindow3);
     void setCommandWindowWheel(MouseCommand commandWindowWheel);
     void setCommandAll1(MouseCommand commandAll1);
     void setCommandAll2(MouseCommand commandAll2);
     void setCommandAll3(MouseCommand commandAll3);
     void setKeyCmdAllModKey(uint keyCmdAllModKey);
     void setShowGeometryTip(bool showGeometryTip);
     void setCondensedTitle(bool condensedTitle);
     void setElectricBorderMaximize(bool electricBorderMaximize);
     void setElectricBorderTiling(bool electricBorderTiling);
     void setElectricBorderCornerRatio(float electricBorderCornerRatio);
     void setBorderlessMaximizedWindows(bool borderlessMaximizedWindows);
     void setKillPingTimeout(int killPingTimeout);
     void setHideUtilityWindowsForInactive(bool hideUtilityWindowsForInactive);
     void setCompositingMode(int compositingMode);
     void setUseCompositing(bool useCompositing);
     void setHiddenPreviews(int hiddenPreviews);
     void setGlSmoothScale(int glSmoothScale);
     void setXrenderSmoothScale(bool xrenderSmoothScale);
     void setMaxFpsInterval(qint64 maxFpsInterval);
     void setRefreshRate(uint refreshRate);
     void setVBlankTime(qint64 vBlankTime);
     void setGlStrictBinding(bool glStrictBinding);
     void setGlStrictBindingFollowsDriver(bool glStrictBindingFollowsDriver);
     void setGLCoreProfile(bool glCoreProfile);
     void setGlPreferBufferSwap(char glPreferBufferSwap);
     void setGlPlatformInterface(OpenGLPlatformInterface interface);
     void setWindowsBlockCompositing(bool set);
 
     // default values
     static WindowOperation defaultOperationTitlebarDblClick() {
         return MaximizeOp;
     }
     static WindowOperation defaultOperationMaxButtonLeftClick() {
         return MaximizeOp;
     }
     static WindowOperation defaultOperationMaxButtonRightClick() {
         return HMaximizeOp;
     }
     static WindowOperation defaultOperationMaxButtonMiddleClick() {
         return VMaximizeOp;
     }
     static MouseCommand defaultCommandActiveTitlebar1() {
         return MouseRaise;
     }
     static MouseCommand defaultCommandActiveTitlebar2() {
         return MouseNothing;
     }
     static MouseCommand defaultCommandActiveTitlebar3() {
         return MouseOperationsMenu;
     }
     static MouseCommand defaultCommandInactiveTitlebar1() {
         return MouseActivateAndRaise;
     }
     static MouseCommand defaultCommandInactiveTitlebar2() {
         return MouseNothing;
     }
     static MouseCommand defaultCommandInactiveTitlebar3() {
         return MouseOperationsMenu;
     }
     static MouseCommand defaultCommandWindow1() {
         return MouseActivateRaiseAndPassClick;
     }
     static MouseCommand defaultCommandWindow2() {
         return MouseActivateAndPassClick;
     }
     static MouseCommand defaultCommandWindow3() {
         return MouseActivateAndPassClick;
     }
     static MouseCommand defaultCommandWindowWheel() {
         return MouseNothing;
     }
     static MouseCommand defaultCommandAll1() {
         return MouseUnrestrictedMove;
     }
     static MouseCommand defaultCommandAll2() {
         return MouseToggleRaiseAndLower;
     }
     static MouseCommand defaultCommandAll3() {
         return MouseUnrestrictedResize;
     }
     static MouseWheelCommand defaultCommandTitlebarWheel() {
         return MouseWheelNothing;
     }
     static MouseWheelCommand defaultCommandAllWheel() {
         return MouseWheelNothing;
     }
     static uint defaultKeyCmdAllModKey() {
         return Qt::Key_Alt;
     }
     static CompositingType defaultCompositingMode() {
         return OpenGLCompositing;
     }
     static bool defaultUseCompositing() {
         return true;
     }
     static HiddenPreviews defaultHiddenPreviews() {
         return HiddenPreviewsShown;
     }
     static int defaultGlSmoothScale() {
         return 2;
     }
     static bool defaultXrenderSmoothScale() {
         return false;
     }
     static qint64 defaultMaxFpsInterval() {
         return (1 * 1000 * 1000 * 1000) /60.0; // nanoseconds / Hz
     }
     static int defaultMaxFps() {
         return 60;
     }
     static uint defaultRefreshRate() {
         return 0;
     }
     static uint defaultVBlankTime() {
         return 6000; // 6ms
     }
     static bool defaultGlStrictBinding() {
         return true;
     }
     static bool defaultGlStrictBindingFollowsDriver() {
         return true;
     }
     static bool defaultGLCoreProfile() {
         return false;
     }
     static GlSwapStrategy defaultGlPreferBufferSwap() {
         return AutoSwapStrategy;
     }
     static OpenGLPlatformInterface defaultGlPlatformInterface() {
         return kwinApp()->shouldUseWaylandForCompositing() ? EglPlatformInterface : GlxPlatformInterface;
     }
     /**
      * Performs loading all settings except compositing related.
      */
     void loadConfig();
     /**
      * Performs loading of compositing settings which do not depend on OpenGL.
      */
     bool loadCompositingConfig(bool force);
     void reparseConfiguration();
 
     static int currentRefreshRate();
 
     //----------------------
 Q_SIGNALS:
     // for properties
     void focusPolicyChanged();
     void focusPolicyIsResonableChanged();
     void nextFocusPrefersMouseChanged();
     void clickRaiseChanged();
     void autoRaiseChanged();
     void autoRaiseIntervalChanged();
     void delayFocusIntervalChanged();
     void shadeHoverChanged();
     void shadeHoverIntervalChanged();
     void separateScreenFocusChanged(bool);
     void placementChanged();
     void borderSnapZoneChanged();
     void windowSnapZoneChanged();
     void centerSnapZoneChanged();
     void snapOnlyWhenOverlappingChanged();
     void rollOverDesktopsChanged(bool enabled);
     void focusStealingPreventionLevelChanged();
     void operationTitlebarDblClickChanged();
     void operationMaxButtonLeftClickChanged();
     void operationMaxButtonRightClickChanged();
     void operationMaxButtonMiddleClickChanged();
     void commandActiveTitlebar1Changed();
     void commandActiveTitlebar2Changed();
     void commandActiveTitlebar3Changed();
     void commandInactiveTitlebar1Changed();
     void commandInactiveTitlebar2Changed();
     void commandInactiveTitlebar3Changed();
     void commandWindow1Changed();
     void commandWindow2Changed();
     void commandWindow3Changed();
     void commandWindowWheelChanged();
     void commandAll1Changed();
     void commandAll2Changed();
     void commandAll3Changed();
     void keyCmdAllModKeyChanged();
     void showGeometryTipChanged();
     void condensedTitleChanged();
     void electricBorderMaximizeChanged();
     void electricBorderTilingChanged();
     void electricBorderCornerRatioChanged();
     void borderlessMaximizedWindowsChanged();
     void killPingTimeoutChanged();
     void hideUtilityWindowsForInactiveChanged();
     void compositingModeChanged();
     void useCompositingChanged();
     void hiddenPreviewsChanged();
     void glSmoothScaleChanged();
     void xrenderSmoothScaleChanged();
     void maxFpsIntervalChanged();
     void refreshRateChanged();
     void vBlankTimeChanged();
     void glStrictBindingChanged();
     void glStrictBindingFollowsDriverChanged();
     void glCoreProfileChanged();
     void glPreferBufferSwapChanged();
     void glPlatformInterfaceChanged();
     void windowsBlockCompositingChanged();
     void animationSpeedChanged();
 
     void configChanged();
 
 private:
     void setElectricBorders(int borders);
     void syncFromKcfgc();
     QScopedPointer<Settings> m_settings;
     KConfigWatcher::Ptr m_configWatcher;
 
     FocusPolicy m_focusPolicy;
     bool m_nextFocusPrefersMouse;
     bool m_clickRaise;
     bool m_autoRaise;
     int m_autoRaiseInterval;
     int m_delayFocusInterval;
     bool m_shadeHover;
     int m_shadeHoverInterval;
     bool m_separateScreenFocus;
     Placement::Policy m_placement;
     int m_borderSnapZone;
     int m_windowSnapZone;
     int m_centerSnapZone;
     bool m_snapOnlyWhenOverlapping;
     bool m_rollOverDesktops;
     int m_focusStealingPreventionLevel;
     int m_killPingTimeout;
     bool m_hideUtilityWindowsForInactive;
 
     CompositingType m_compositingMode;
     bool m_useCompositing;
     HiddenPreviews m_hiddenPreviews;
     int m_glSmoothScale;
     bool m_xrenderSmoothScale;
     qint64 m_maxFpsInterval;
     // Settings that should be auto-detected
     uint m_refreshRate;
     qint64 m_vBlankTime;
     bool m_glStrictBinding;
     bool m_glStrictBindingFollowsDriver;
     bool m_glCoreProfile;
     GlSwapStrategy m_glPreferBufferSwap;
     OpenGLPlatformInterface m_glPlatformInterface;
     bool m_windowsBlockCompositing;
 
     WindowOperation OpTitlebarDblClick;
     WindowOperation opMaxButtonRightClick = defaultOperationMaxButtonRightClick();
     WindowOperation opMaxButtonMiddleClick = defaultOperationMaxButtonMiddleClick();
     WindowOperation opMaxButtonLeftClick = defaultOperationMaxButtonRightClick();
 
     // mouse bindings
     MouseCommand CmdActiveTitlebar1;
     MouseCommand CmdActiveTitlebar2;
     MouseCommand CmdActiveTitlebar3;
     MouseCommand CmdInactiveTitlebar1;
     MouseCommand CmdInactiveTitlebar2;
     MouseCommand CmdInactiveTitlebar3;
     MouseWheelCommand CmdTitlebarWheel;
     MouseCommand CmdWindow1;
     MouseCommand CmdWindow2;
     MouseCommand CmdWindow3;
     MouseCommand CmdWindowWheel;
     MouseCommand CmdAll1;
     MouseCommand CmdAll2;
     MouseCommand CmdAll3;
     MouseWheelCommand CmdAllWheel;
     uint CmdAllModKey;
 
     bool electric_border_maximize;
     bool electric_border_tiling;
     float electric_border_corner_ratio;
     bool borderless_maximized_windows;
     bool show_geometry_tip;
     bool condensed_title;
 
     QHash<Qt::KeyboardModifier, QStringList> m_modifierOnlyShortcuts;
 
     MouseCommand wheelToMouseCommand(MouseWheelCommand com, int delta) const;
 };
 
 extern KWIN_EXPORT Options* options;
 
 } // namespace
 
 Q_DECLARE_METATYPE(KWin::Options::WindowOperation)
 Q_DECLARE_METATYPE(KWin::OpenGLPlatformInterface)
 
 #endif
diff --git a/platformsupport/scenes/opengl/backend.cpp b/platformsupport/scenes/opengl/backend.cpp
index 45b6fbd30..18fc7e61b 100644
--- a/platformsupport/scenes/opengl/backend.cpp
+++ b/platformsupport/scenes/opengl/backend.cpp
@@ -1,119 +1,118 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 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 "backend.h"
 #include <kwineffects.h>
 #include <logging.h>
 
 #include "screens.h"
 
 #include <epoxy/gl.h>
 
 namespace KWin
 {
 
 OpenGLBackend::OpenGLBackend()
-    : m_syncsToVBlank(false)
-    , m_blocksForRetrace(false)
+    : m_blocksForRetrace(false)
     , m_directRendering(false)
     , m_haveBufferAge(false)
     , m_failed(false)
 {
 }
 
 OpenGLBackend::~OpenGLBackend()
 {
 }
 
 void OpenGLBackend::setFailed(const QString &reason)
 {
     qCWarning(KWIN_OPENGL) << "Creating the OpenGL rendering failed: " << reason;
     m_failed = true;
 }
 
 void OpenGLBackend::idle()
 {
     if (hasPendingFlush()) {
         effects->makeOpenGLContextCurrent();
         present();
     }
 }
 
 void OpenGLBackend::addToDamageHistory(const QRegion &region)
 {
     if (m_damageHistory.count() > 10)
         m_damageHistory.removeLast();
 
     m_damageHistory.prepend(region);
 }
 
 QRegion OpenGLBackend::accumulatedDamageHistory(int bufferAge) const
 {
     QRegion region;
 
     // Note: An age of zero means the buffer contents are undefined
     if (bufferAge > 0 && bufferAge <= m_damageHistory.count()) {
         for (int i = 0; i < bufferAge - 1; i++)
             region |= m_damageHistory[i];
     } else {
         const QSize &s = screens()->size();
         region = QRegion(0, 0, s.width(), s.height());
     }
 
     return region;
 }
 
 OverlayWindow* OpenGLBackend::overlayWindow() const
 {
     return nullptr;
 }
 
 QRegion OpenGLBackend::prepareRenderingForScreen(int screenId)
 {
     // fallback to repaint complete screen
     return screens()->geometry(screenId);
 }
 
 void OpenGLBackend::endRenderingFrameForScreen(int screenId, const QRegion &damage, const QRegion &damagedRegion)
 {
     Q_UNUSED(screenId)
     Q_UNUSED(damage)
     Q_UNUSED(damagedRegion)
 }
 
 bool OpenGLBackend::perScreenRendering() const
 {
     return false;
 }
 
 void OpenGLBackend::copyPixels(const QRegion &region)
 {
     const int height = screens()->size().height();
     for (const QRect &r : region) {
         const int x0 = r.x();
         const int y0 = height - r.y() - r.height();
         const int x1 = r.x() + r.width();
         const int y1 = height - r.y();
 
         glBlitFramebuffer(x0, y0, x1, y1, x0, y0, x1, y1, GL_COLOR_BUFFER_BIT, GL_NEAREST);
     }
 }
 
 }
diff --git a/platformsupport/scenes/opengl/backend.h b/platformsupport/scenes/opengl/backend.h
index 2879f68e6..6e405b663 100644
--- a/platformsupport/scenes/opengl/backend.h
+++ b/platformsupport/scenes/opengl/backend.h
@@ -1,326 +1,302 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 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_SCENE_OPENGL_BACKEND_H
 #define KWIN_SCENE_OPENGL_BACKEND_H
 
 #include <QElapsedTimer>
 #include <QRegion>
 
 #include <kwin_export.h>
 
 namespace KWin
 {
 class OpenGLBackend;
 class OverlayWindow;
 class SceneOpenGL;
 class SceneOpenGLTexture;
 class SceneOpenGLTexturePrivate;
 class WindowPixmap;
 
 /**
  * @brief The OpenGLBackend creates and holds the OpenGL context and is responsible for Texture from Pixmap.
  *
  * The OpenGLBackend is an abstract base class used by the SceneOpenGL to abstract away the differences
  * between various OpenGL windowing systems such as GLX and EGL.
  *
  * A concrete implementation has to create and release the OpenGL context in a way so that the
  * SceneOpenGL does not have to care about it.
  *
  * In addition a major task for this class is to generate the SceneOpenGLTexturePrivate which is
  * able to perform the texture from pixmap operation in the given backend.
  *
  * @author Martin Gräßlin <mgraesslin@kde.org>
  */
 class KWIN_EXPORT OpenGLBackend
 {
 public:
     OpenGLBackend();
     virtual ~OpenGLBackend();
 
     virtual void init() = 0;
     /**
      * @return Time passes since start of rendering current frame.
      * @see startRenderTimer
      */
     qint64 renderTime() {
         return m_renderTimer.nsecsElapsed();
     }
     virtual void screenGeometryChanged(const QSize &size) = 0;
     virtual SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) = 0;
 
     /**
      * @brief Backend specific code to prepare the rendering of a frame including flushing the
      * previously rendered frame to the screen if the backend works this way.
      *
      * @return A region that if not empty will be repainted in addition to the damaged region
      */
     virtual QRegion prepareRenderingFrame() = 0;
 
     /**
      * @brief Backend specific code to handle the end of rendering a frame.
      *
      * @param renderedRegion The possibly larger region that has been rendered
      * @param damagedRegion The damaged region that should be posted
      */
     virtual void endRenderingFrame(const QRegion &damage, const QRegion &damagedRegion) = 0;
     virtual void endRenderingFrameForScreen(int screenId, const QRegion &damage, const QRegion &damagedRegion);
     virtual bool makeCurrent() = 0;
     virtual void doneCurrent() = 0;
     virtual bool usesOverlayWindow() const = 0;
     /**
      * Whether the rendering needs to be split per screen.
      * Default implementation returns @c false.
      */
     virtual bool perScreenRendering() const;
     virtual QRegion prepareRenderingForScreen(int screenId);
     /**
      * @brief Compositor is going into idle mode, flushes any pending paints.
      */
     void idle();
 
     /**
      * @return bool Whether the scene needs to flush a frame.
      */
     bool hasPendingFlush() const {
         return !m_lastDamage.isEmpty();
     }
 
     /**
      * @brief Returns the OverlayWindow used by the backend.
      *
      * A backend does not have to use an OverlayWindow, this is mostly for the X world.
      * In case the backend does not use an OverlayWindow it is allowed to return @c null.
      * It's the task of the caller to check whether it is @c null.
      *
      * @return :OverlayWindow*
      */
     virtual OverlayWindow *overlayWindow() const;
     /**
      * @brief Whether the creation of the Backend failed.
      *
      * The SceneOpenGL should test whether the Backend got constructed correctly. If this method
      * returns @c true, the SceneOpenGL should not try to start the rendering.
      *
      * @return bool @c true if the creation of the Backend failed, @c false otherwise.
      */
     bool isFailed() const {
         return m_failed;
     }
-    /**
-     * @brief Whether the Backend provides VSync.
-     *
-     * Currently only the GLX backend can provide VSync.
-     *
-     * @return bool @c true if VSync support is available, @c false otherwise
-     */
-    bool syncsToVBlank() const {
-        return m_syncsToVBlank;
-    }
     /**
      * @brief Whether VSync blocks execution until the screen is in the retrace
      *
      * Case for waitVideoSync and non triple buffering buffer swaps (triple buffering support
      * has been removed).
      *
      */
     bool blocksForRetrace() const {
         return m_blocksForRetrace;
     }
     /**
      * @brief Whether the backend uses direct rendering.
      *
      * Some OpenGLScene modes require direct rendering. E.g. the OpenGL 2 should not be used
      * if direct rendering is not supported by the Scene.
      *
      * @return bool @c true if the GL context is direct, @c false if indirect
      */
     bool isDirectRendering() const {
         return m_directRendering;
     }
 
     bool supportsBufferAge() const {
         return m_haveBufferAge;
     }
 
     /**
      * @returns whether the context is surfaceless
      */
     bool isSurfaceLessContext() const {
         return m_surfaceLessContext;
     }
 
     /**
      * Returns the damage that has accumulated since a buffer of the given age was presented.
      */
     QRegion accumulatedDamageHistory(int bufferAge) const;
 
     /**
      * Saves the given region to damage history.
      */
     void addToDamageHistory(const QRegion &region);
 
     /**
      * The backend specific extensions (e.g. EGL/GLX extensions).
      *
      * Not the OpenGL (ES) extension!
      */
     QList<QByteArray> extensions() const {
         return m_extensions;
     }
 
     /**
      * @returns whether the backend specific extensions contains @p extension.
      */
     bool hasExtension(const QByteArray &extension) const {
         return m_extensions.contains(extension);
     }
 
     /**
      * Copy a region of pixels from the current read to the current draw buffer
      */
     void copyPixels(const QRegion &region);
 
 protected:
     /**
      * @brief Backend specific flushing of frame to screen.
      */
     virtual void present() = 0;
     /**
      * @brief Sets the backend initialization to failed.
      *
      * This method should be called by the concrete subclass in case the initialization failed.
      * The given @p reason is logged as a warning.
      *
      * @param reason The reason why the initialization failed.
      */
     void setFailed(const QString &reason);
-    /**
-     * @brief Sets whether the backend provides VSync.
-     *
-     * Should be called by the concrete subclass once it is determined whether VSync is supported.
-     * If the subclass does not call this method, the backend defaults to @c false.
-     * @param enabled @c true if VSync support available, @c false otherwise.
-     */
-    void setSyncsToVBlank(bool enabled) {
-        m_syncsToVBlank = enabled;
-    }
     /**
      * @brief Sets whether the VSync iplementation blocks
      *
      * Should be called by the concrete subclass once it is determined how VSync works.
      * If the subclass does not call this method, the backend defaults to @c false.
      * @param enabled @c true if VSync blocks, @c false otherwise.
      */
     void setBlocksForRetrace(bool enabled) {
         m_blocksForRetrace = enabled;
     }
     /**
      * @brief Sets whether the OpenGL context is direct.
      *
      * Should be called by the concrete subclass once it is determined whether the OpenGL context is
      * direct or indirect.
      * If the subclass does not call this method, the backend defaults to @c false.
      *
      * @param direct @c true if the OpenGL context is direct, @c false if indirect
      */
     void setIsDirectRendering(bool direct) {
         m_directRendering = direct;
     }
 
     void setSupportsBufferAge(bool value) {
         m_haveBufferAge = value;
     }
 
     /**
      * @return const QRegion& Damage of previously rendered frame
      */
     const QRegion &lastDamage() const {
         return m_lastDamage;
     }
     void setLastDamage(const QRegion &damage) {
         m_lastDamage = damage;
     }
     /**
      * @brief Starts the timer for how long it takes to render the frame.
      *
      * @see renderTime
      */
     void startRenderTimer() {
         m_renderTimer.start();
     }
 
     /**
      * @param set whether the context is surface less
      */
     void setSurfaceLessContext(bool set) {
         m_surfaceLessContext = set;
     }
 
     /**
      * Sets the platform-specific @p extensions.
      *
      * These are the EGL/GLX extensions, not the OpenGL extensions
      */
     void setExtensions(const QList<QByteArray> &extensions) {
         m_extensions = extensions;
     }
 
 private:
-    /**
-     * @brief Whether VSync is available and used, defaults to @c false.
-     */
-    bool m_syncsToVBlank;
     /**
      * @brief Whether present() will block execution until the next vertical retrace @c false.
      */
     bool m_blocksForRetrace;
     /**
      * @brief Whether direct rendering is used, defaults to @c false.
      */
     bool m_directRendering;
     /**
      * @brief Whether the backend supports GLX_EXT_buffer_age / EGL_EXT_buffer_age.
      */
     bool m_haveBufferAge;
     /**
      * @brief Whether the initialization failed, of course default to @c false.
      */
     bool m_failed;
     /**
      * @brief Damaged region of previously rendered frame.
      */
     QRegion m_lastDamage;
     /**
      * @brief The damage history for the past 10 frames.
      */
     QList<QRegion> m_damageHistory;
     /**
      * @brief Timer to measure how long a frame renders.
      */
     QElapsedTimer m_renderTimer;
     bool m_surfaceLessContext = false;
 
     QList<QByteArray> m_extensions;
 };
 
 }
 
 #endif
diff --git a/plugins/platforms/drm/egl_gbm_backend.cpp b/plugins/platforms/drm/egl_gbm_backend.cpp
index 48ec495b2..c63635d53 100644
--- a/plugins/platforms/drm/egl_gbm_backend.cpp
+++ b/plugins/platforms/drm/egl_gbm_backend.cpp
@@ -1,426 +1,425 @@
 /********************************************************************
  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 "egl_gbm_backend.h"
 // kwin
 #include "composite.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "gbm_surface.h"
 #include "logging.h"
 #include "options.h"
 #include "screens.h"
 // kwin libs
 #include <kwinglplatform.h>
 // Qt
 #include <QOpenGLContext>
 // system
 #include <gbm.h>
 
 namespace KWin
 {
 
 EglGbmBackend::EglGbmBackend(DrmBackend *b)
     : AbstractEglBackend()
     , m_backend(b)
 {
     // Egl is always direct rendering
     setIsDirectRendering(true);
-    setSyncsToVBlank(true);
     connect(m_backend, &DrmBackend::outputAdded, this, &EglGbmBackend::createOutput);
     connect(m_backend, &DrmBackend::outputRemoved, this,
         [this] (DrmOutput *output) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [output] (const Output &o) {
                     return o.output == output;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             cleanupOutput(*it);
             m_outputs.erase(it);
         }
     );
 }
 
 EglGbmBackend::~EglGbmBackend()
 {
     cleanup();
 }
 
 void EglGbmBackend::cleanupSurfaces()
 {
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         cleanupOutput(*it);
     }
     m_outputs.clear();
 }
 
 void EglGbmBackend::cleanupOutput(const Output &o)
 {
     o.output->releaseGbm();
 
     if (o.eglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
 }
 
 bool EglGbmBackend::initializeEgl()
 {
     initClientExtensions();
     EGLDisplay display = m_backend->sceneEglDisplay();
 
     // Use eglGetPlatformDisplayEXT() to get the display pointer
     // if the implementation supports it.
     if (display == EGL_NO_DISPLAY) {
         const bool hasMesaGBM = hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"));
         const bool hasKHRGBM = hasClientExtension(QByteArrayLiteral("EGL_KHR_platform_gbm"));
         const GLenum platform = hasMesaGBM ? EGL_PLATFORM_GBM_MESA : EGL_PLATFORM_GBM_KHR;
 
         if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
                 (!hasMesaGBM && !hasKHRGBM)) {
             setFailed("missing one or more extensions between EGL_EXT_platform_base,  EGL_MESA_platform_gbm, EGL_KHR_platform_gbm");
             return false;
         }
 
         auto device = gbm_create_device(m_backend->fd());
         if (!device) {
             setFailed("Could not create gbm device");
             return false;
         }
         m_backend->setGbmDevice(device);
 
         display = eglGetPlatformDisplayEXT(platform, device, nullptr);
     }
 
     if (display == EGL_NO_DISPLAY)
         return false;
     setEglDisplay(display);
     return initEglAPI();
 }
 
 void EglGbmBackend::init()
 {
     if (!initializeEgl()) {
         setFailed("Could not initialize egl");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Could not initialize rendering context");
         return;
     }
 
     initKWinGL();
     initBufferAge();
     initWayland();
     initRemotePresent();
 }
 
 bool EglGbmBackend::initRenderingContext()
 {
     initBufferConfigs();
 
     if (!createContext()) {
         return false;
     }
 
     const auto outputs = m_backend->drmOutputs();
     for (DrmOutput *drmOutput: outputs) {
         createOutput(drmOutput);
     }
     if (m_outputs.isEmpty()) {
         qCCritical(KWIN_DRM) << "Create Window Surfaces failed";
         return false;
     }
     // set our first surface as the one for the abstract backend, just to make it happy
     setSurface(m_outputs.first().eglSurface);
 
     return makeContextCurrent(m_outputs.first());
 }
 
 void EglGbmBackend::initRemotePresent()
 {
     if (qEnvironmentVariableIsSet("KWIN_NO_REMOTE")) {
         return;
     }
 
     qCDebug(KWIN_DRM) << "Support for remote access enabled";
     m_remoteaccessManager.reset(new RemoteAccessManager);
 }
 
 bool EglGbmBackend::resetOutput(Output &o, DrmOutput *drmOutput)
 {
     o.output = drmOutput;
     auto size = drmOutput->pixelSize();
 
     auto gbmSurface = std::make_shared<GbmSurface>(m_backend->gbmDevice(), size.width(), size.height(),
                                         GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
     if (!gbmSurface) {
         qCCritical(KWIN_DRM) << "Create gbm surface failed";
         return false;
     }
     auto eglSurface = eglCreatePlatformWindowSurfaceEXT(eglDisplay(), config(), (void *)(gbmSurface->surface()), nullptr);
     if (eglSurface == EGL_NO_SURFACE) {
         qCCritical(KWIN_DRM) << "Create Window Surface failed";
         return false;
     } else {
         // destroy previous surface
         if (o.eglSurface != EGL_NO_SURFACE) {
             if (surface() == o.eglSurface) {
                 setSurface(eglSurface);
             }
             eglDestroySurface(eglDisplay(), o.eglSurface);
         }
         o.eglSurface = eglSurface;
         o.gbmSurface = gbmSurface;
     }
     return true;
 }
 
 void EglGbmBackend::createOutput(DrmOutput *drmOutput)
 {
     Output o;
     if (resetOutput(o, drmOutput)) {
         connect(drmOutput, &DrmOutput::modeChanged, this,
             [drmOutput, this] {
                 auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                     [drmOutput] (const auto &o) {
                         return o.output == drmOutput;
                     }
                 );
                 if (it == m_outputs.end()) {
                     return;
                 }
                 resetOutput(*it, drmOutput);
             }
         );
         m_outputs << o;
     }
 }
 
 bool EglGbmBackend::makeContextCurrent(const Output &output)
 {
     const EGLSurface surface = output.eglSurface;
     if (surface == EGL_NO_SURFACE) {
         return false;
     }
     if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
         qCCritical(KWIN_DRM) << "Make Context Current failed";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_DRM) << "Error occurred while creating context " << error;
         return false;
     }
     // TODO: ensure the viewport is set correctly each time
     const QSize &overall = screens()->size();
     const QRect &v = output.output->geometry();
     // TODO: are the values correct?
 
     qreal scale = output.output->scale();
 
     glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
                overall.width() * scale, overall.height() * scale);
     return true;
 }
 
 bool EglGbmBackend::initBufferConfigs()
 {
     const EGLint config_attribs[] = {
         EGL_SURFACE_TYPE,         EGL_WINDOW_BIT,
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
 
     EGLint count;
     EGLConfig configs[1024];
     if (!eglChooseConfig(eglDisplay(), config_attribs, configs, sizeof(configs)/sizeof(EGLConfig), &count)) {
         qCCritical(KWIN_DRM) << "choose config failed";
         return false;
     }
 
     qCDebug(KWIN_DRM) << "EGL buffer configs count:" << count;
 
     // loop through all configs, chosing the first one that has suitable format
     for (EGLint i = 0; i < count; i++) {
         EGLint gbmFormat;
         // query some configuration parameters, to show in debug log
         eglGetConfigAttrib(eglDisplay(), configs[i], EGL_NATIVE_VISUAL_ID, &gbmFormat);
 
         if (KWIN_DRM().isDebugEnabled()) {
             // GBM formats are declared as FOURCC code (integer from ASCII chars, so use this fact)
             char gbmFormatStr[sizeof(EGLint) + 1] = {0};
             memcpy(gbmFormatStr, &gbmFormat, sizeof(EGLint));
             // query number of bits for color channel
             EGLint blueSize, redSize, greenSize, alphaSize;
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_RED_SIZE, &redSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_GREEN_SIZE, &greenSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_BLUE_SIZE, &blueSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_ALPHA_SIZE, &alphaSize);
             qCDebug(KWIN_DRM) << "  EGL config #" << i << " has GBM FOURCC format:" << gbmFormatStr
                               << "; color sizes (RGBA order):" << redSize << greenSize << blueSize << alphaSize;
         }
 
         if ((gbmFormat == GBM_FORMAT_XRGB8888) || (gbmFormat == GBM_FORMAT_ARGB8888)) {
             setConfig(configs[i]);
             return true;
         }
     }
 
     qCCritical(KWIN_DRM) << "choose EGL config did not return a suitable config" << count;
     return false;
 }
 
 void EglGbmBackend::present()
 {
     for (auto &o: m_outputs) {
         makeContextCurrent(o);
         presentOnOutput(o);
     }
 }
 
 void EglGbmBackend::presentOnOutput(EglGbmBackend::Output &o)
 {
     eglSwapBuffers(eglDisplay(), o.eglSurface);
     o.buffer = m_backend->createBuffer(o.gbmSurface);
     if(m_remoteaccessManager && gbm_surface_has_free_buffers(o.gbmSurface->surface())) {
         // GBM surface is released on page flip so
         // we should pass the buffer before it's presented
         m_remoteaccessManager->passBuffer(o.output, o.buffer);
     }
     m_backend->present(o.buffer, o.output);
 
     if (supportsBufferAge()) {
         eglQuerySurface(eglDisplay(), o.eglSurface, EGL_BUFFER_AGE_EXT, &o.bufferAge);
     }
 
 }
 
 void EglGbmBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
     // TODO, create new buffer?
 }
 
 SceneOpenGLTexturePrivate *EglGbmBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglGbmTexture(texture, this);
 }
 
 QRegion EglGbmBackend::prepareRenderingFrame()
 {
     startRenderTimer();
     return QRegion();
 }
 
 QRegion EglGbmBackend::prepareRenderingForScreen(int screenId)
 {
     const Output &o = m_outputs.at(screenId);
     makeContextCurrent(o);
     if (supportsBufferAge()) {
         QRegion region;
 
         // Note: An age of zero means the buffer contents are undefined
         if (o.bufferAge > 0 && o.bufferAge <= o.damageHistory.count()) {
             for (int i = 0; i < o.bufferAge - 1; i++)
                 region |= o.damageHistory[i];
         } else {
             region = o.output->geometry();
         }
 
         return region;
     }
     return QRegion();
 }
 
 void EglGbmBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion)
     Q_UNUSED(damagedRegion)
 }
 
 void EglGbmBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Output &o = m_outputs[screenId];
     if (damagedRegion.intersected(o.output->geometry()).isEmpty() && screenId == 0) {
 
         // If the damaged region of a window is fully occluded, the only
         // rendering done, if any, will have been to repair a reused back
         // buffer, making it identical to the front buffer.
         //
         // In this case we won't post the back buffer. Instead we'll just
         // set the buffer age to 1, so the repaired regions won't be
         // rendered again in the next frame.
         if (!renderedRegion.intersected(o.output->geometry()).isEmpty())
             glFlush();
 
         for (auto &o: m_outputs) {
             o.bufferAge = 1;
         }
         return;
     }
     presentOnOutput(o);
 
     // Save the damaged region to history
     // Note: damage history is only collected for the first screen. For any other screen full repaints
     // are triggered. This is due to a limitation in Scene::paintGenericScreen which resets the Toplevel's
     // repaint. So multiple calls to Scene::paintScreen as it's done in multi-output rendering only
     // have correct damage information for the first screen. If we try to track damage nevertheless,
     // it creates artifacts. So for the time being we work around the problem by only supporting buffer
     // age on the first output. To properly support buffer age on all outputs the rendering needs to
     // be refactored in general.
     if (supportsBufferAge() && screenId == 0) {
         if (o.damageHistory.count() > 10) {
             o.damageHistory.removeLast();
         }
 
         o.damageHistory.prepend(damagedRegion.intersected(o.output->geometry()));
     }
 }
 
 bool EglGbmBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool EglGbmBackend::perScreenRendering() const
 {
     return true;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglGbmTexture::EglGbmTexture(KWin::SceneOpenGLTexture *texture, EglGbmBackend *backend)
     : AbstractEglTexture(texture, backend)
 {
 }
 
 EglGbmTexture::~EglGbmTexture() = default;
 
 } // namespace
diff --git a/plugins/platforms/drm/egl_stream_backend.cpp b/plugins/platforms/drm/egl_stream_backend.cpp
index 374ab42bb..ce5741d95 100644
--- a/plugins/platforms/drm/egl_stream_backend.cpp
+++ b/plugins/platforms/drm/egl_stream_backend.cpp
@@ -1,692 +1,691 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 NVIDIA Inc.
 
 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 "egl_stream_backend.h"
 #include "composite.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "drm_object_crtc.h"
 #include "drm_object_plane.h"
 #include "logging.h"
 #include "logind.h"
 #include "options.h"
 #include "scene.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include <kwinglplatform.h>
 #include <QOpenGLContext>
 #include <KWayland/Server/surface_interface.h>
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/eglstream_controller_interface.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/resource.h>
 #include <wayland-server-core.h>
 
 namespace KWin
 {
 
 typedef EGLStreamKHR (*PFNEGLCREATESTREAMATTRIBNV)(EGLDisplay, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLGETOUTPUTLAYERSEXT)(EGLDisplay, EGLAttrib *, EGLOutputLayerEXT *, EGLint, EGLint *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMEROUTPUTEXT)(EGLDisplay, EGLStreamKHR, EGLOutputLayerEXT);
 typedef EGLSurface (*PFNEGLCREATESTREAMPRODUCERSURFACEKHR)(EGLDisplay, EGLConfig, EGLStreamKHR, EGLint *);
 typedef EGLBoolean (*PFNEGLDESTROYSTREAMKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLQUERYSTREAMATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLenum, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERRELEASEKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLQUERYWAYLANDBUFFERWL)(EGLDisplay, wl_resource *, EGLint, EGLint *);
 PFNEGLCREATESTREAMATTRIBNV pEglCreateStreamAttribNV = nullptr;
 PFNEGLGETOUTPUTLAYERSEXT pEglGetOutputLayersEXT = nullptr;
 PFNEGLSTREAMCONSUMEROUTPUTEXT pEglStreamConsumerOutputEXT = nullptr;
 PFNEGLCREATESTREAMPRODUCERSURFACEKHR pEglCreateStreamProducerSurfaceKHR = nullptr;
 PFNEGLDESTROYSTREAMKHR pEglDestroyStreamKHR = nullptr;
 PFNEGLSTREAMCONSUMERACQUIREATTRIBNV pEglStreamConsumerAcquireAttribNV = nullptr;
 PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR pEglStreamConsumerGLTextureExternalKHR = nullptr;
 PFNEGLQUERYSTREAMATTRIBNV pEglQueryStreamAttribNV = nullptr;
 PFNEGLSTREAMCONSUMERRELEASEKHR pEglStreamConsumerReleaseKHR = nullptr;
 PFNEGLQUERYWAYLANDBUFFERWL pEglQueryWaylandBufferWL = nullptr;
     
 #ifndef EGL_CONSUMER_AUTO_ACQUIRE_EXT
 #define EGL_CONSUMER_AUTO_ACQUIRE_EXT 0x332B
 #endif
 
 #ifndef EGL_DRM_MASTER_FD_EXT
 #define EGL_DRM_MASTER_FD_EXT 0x333C
 #endif
 
 #ifndef EGL_DRM_FLIP_EVENT_DATA_NV
 #define EGL_DRM_FLIP_EVENT_DATA_NV 0x333E
 #endif
 
 #ifndef EGL_WAYLAND_EGLSTREAM_WL
 #define EGL_WAYLAND_EGLSTREAM_WL 0x334B
 #endif
 
 #ifndef EGL_WAYLAND_Y_INVERTED_WL
 #define EGL_WAYLAND_Y_INVERTED_WL 0x31DB
 #endif    
 
 EglStreamBackend::EglStreamBackend(DrmBackend *b)
     : AbstractEglBackend(), m_backend(b)
 {
     setIsDirectRendering(true);
-    setSyncsToVBlank(true);
     connect(m_backend, &DrmBackend::outputAdded, this, &EglStreamBackend::createOutput);
     connect(m_backend, &DrmBackend::outputRemoved, this,
         [this] (DrmOutput *output) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                                    [output] (const Output &o) {
                                        return o.output == output;
                                    });
             if (it == m_outputs.end()) {
                 return;
             }
             cleanupOutput(*it);
             m_outputs.erase(it);
         });
 }
 
 EglStreamBackend::~EglStreamBackend()
 {
     cleanup();
 }
 
 void EglStreamBackend::cleanupSurfaces()
 {
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         cleanupOutput(*it);
     }
     m_outputs.clear();
 }
 
 void EglStreamBackend::cleanupOutput(const Output &o)
 {
     if (o.buffer != nullptr) {
         delete o.buffer;
     }
     if (o.eglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
     if (o.eglStream != EGL_NO_STREAM_KHR) {
         pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
     }
 }
 
 bool EglStreamBackend::initializeEgl()
 {
     initClientExtensions();
     EGLDisplay display = m_backend->sceneEglDisplay();
     if (display == EGL_NO_DISPLAY) {
         if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_device_base")) &&
             !(hasClientExtension(QByteArrayLiteral("EGL_EXT_device_query")) &&
               hasClientExtension(QByteArrayLiteral("EGL_EXT_device_enumeration")))) {
             setFailed("Missing required EGL client extension: "
                       "EGL_EXT_device_base or "
                       "EGL_EXT_device_query and EGL_EXT_device_enumeration");
             return false;
         }
 
         // Try to find the EGLDevice corresponding to our DRM device file
         int numDevices;
         eglQueryDevicesEXT(0, nullptr, &numDevices);
         QVector<EGLDeviceEXT> devices(numDevices);
         eglQueryDevicesEXT(numDevices, devices.data(), &numDevices);
         for (EGLDeviceEXT device : devices) {
             const char *drmDeviceFile = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
             if (m_backend->devNode() != drmDeviceFile) {
                 continue;
             }
             
             const char *deviceExtensionCString = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
             QByteArray deviceExtensions = QByteArray::fromRawData(deviceExtensionCString,
                                                                   qstrlen(deviceExtensionCString));
             if (!deviceExtensions.split(' ').contains(QByteArrayLiteral("EGL_EXT_device_drm"))) {
                 continue;
             }
                 
             EGLint platformAttribs[] = {
                 EGL_DRM_MASTER_FD_EXT, m_backend->fd(),
                 EGL_NONE
             };
             display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, platformAttribs);
             break;
         }
     }
 
     if (display == EGL_NO_DISPLAY) {
         setFailed("No suitable EGL device found");
         return false;
     }
     
     setEglDisplay(display);
     if (!initEglAPI()) {
         return false;
     }
 
     const QVector<QByteArray> requiredExtensions = {
         QByteArrayLiteral("EGL_EXT_output_base"),
         QByteArrayLiteral("EGL_EXT_output_drm"),
         QByteArrayLiteral("EGL_KHR_stream"),
         QByteArrayLiteral("EGL_KHR_stream_producer_eglsurface"),
         QByteArrayLiteral("EGL_EXT_stream_consumer_egloutput"),
         QByteArrayLiteral("EGL_NV_stream_attrib"),
         QByteArrayLiteral("EGL_EXT_stream_acquire_mode"),
         QByteArrayLiteral("EGL_KHR_stream_consumer_gltexture"),
         QByteArrayLiteral("EGL_WL_wayland_eglstream")
     };
     for (const QByteArray &ext : requiredExtensions) {
         if (!hasExtension(ext)) {
             setFailed(QStringLiteral("Missing required EGL extension: ") + ext);
             return false;
         }
     }
 
     pEglCreateStreamAttribNV = (PFNEGLCREATESTREAMATTRIBNV)eglGetProcAddress("eglCreateStreamAttribNV");
     pEglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXT)eglGetProcAddress("eglGetOutputLayersEXT");
     pEglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXT)eglGetProcAddress("eglStreamConsumerOutputEXT");
     pEglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHR)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
     pEglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHR)eglGetProcAddress("eglDestroyStreamKHR");
     pEglStreamConsumerAcquireAttribNV = (PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)eglGetProcAddress("eglStreamConsumerAcquireAttribNV");
     pEglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR");
     pEglQueryStreamAttribNV = (PFNEGLQUERYSTREAMATTRIBNV)eglGetProcAddress("eglQueryStreamAttribNV");
     pEglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHR)eglGetProcAddress("eglStreamConsumerReleaseKHR");
     pEglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWL)eglGetProcAddress("eglQueryWaylandBufferWL");
     return true;
 }
 
 EglStreamBackend::StreamTexture *EglStreamBackend::lookupStreamTexture(KWayland::Server::SurfaceInterface *surface)
 {
     auto it = m_streamTextures.find(surface);
     return it != m_streamTextures.end() ?
            &it.value() : 
            nullptr;
 }
 
 void EglStreamBackend::attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
                                             void *eglStream,
                                             wl_array *attribs)
 {
     QVector<EGLAttrib> streamAttribs;
     streamAttribs << EGL_WAYLAND_EGLSTREAM_WL << (EGLAttrib)eglStream;
     EGLAttrib *attribArray = (EGLAttrib *)attribs->data;
     for (unsigned int i = 0; i < attribs->size; ++i) {
         streamAttribs << attribArray[i];
     }
     streamAttribs << EGL_NONE;
 
     EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs.data());
     if (stream == EGL_NO_STREAM_KHR) {
         qCWarning(KWIN_DRM) << "Failed to create EGL stream";
         return;
     }
 
     GLuint texture;
     StreamTexture *st = lookupStreamTexture(surface);
     if (st != nullptr) {
         pEglDestroyStreamKHR(eglDisplay(), st->stream);
         st->stream = stream;
         texture = st->texture;
     } else {
         StreamTexture newSt = { stream, 0 };
         glGenTextures(1, &newSt.texture);
         m_streamTextures.insert(surface, newSt);
         texture = newSt.texture;
 
         connect(surface, &KWayland::Server::Resource::unbound, this,
             [surface, this]() {
                 const StreamTexture &st = m_streamTextures.take(surface);
                 pEglDestroyStreamKHR(eglDisplay(), st.stream);
                 glDeleteTextures(1, &st.texture);
             });
     }
 
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
     if (!pEglStreamConsumerGLTextureExternalKHR(eglDisplay(), stream)) {
         qCWarning(KWIN_DRM) << "Failed to bind EGL stream to texture";
     }
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
 }
 
 void EglStreamBackend::init()
 {
     if (!m_backend->atomicModeSetting()) {
         setFailed("EGLStream backend requires atomic modesetting");
         return;
     }
     
     if (!initializeEgl()) {
         setFailed("Failed to initialize EGL api");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Failed to initialize rendering context");
         return;
     }
 
     initKWinGL();
     setSupportsBufferAge(false);
     initWayland();
 
     using namespace KWayland::Server;
     m_eglStreamControllerInterface = waylandServer()->display()->createEglStreamControllerInterface();
     connect(m_eglStreamControllerInterface, &EglStreamControllerInterface::streamConsumerAttached, this,
             &EglStreamBackend::attachStreamConsumer);
     m_eglStreamControllerInterface->create();
     if (!m_eglStreamControllerInterface->isValid()) {
         setFailed("failed to initialize wayland-eglstream-controller interface");
     }
 }
 
 bool EglStreamBackend::initRenderingContext()
 {
     initBufferConfigs();
 
     if (!createContext()) {
         return false;
     }
 
     const auto outputs = m_backend->drmOutputs();
     for (DrmOutput *drmOutput : outputs) {
         createOutput(drmOutput);
     }
     if (m_outputs.isEmpty()) {
         qCCritical(KWIN_DRM) << "Failed to create output surface";
         return false;
     }
     // set our first surface as the one for the abstract backend
     setSurface(m_outputs.first().eglSurface);
 
     return makeContextCurrent(m_outputs.first());
 }
 
 bool EglStreamBackend::resetOutput(Output &o, DrmOutput *drmOutput)
 {
     o.output = drmOutput;
     if (o.buffer != nullptr) {
         delete o.buffer;
     }
     // dumb buffer used for modesetting
     o.buffer = m_backend->createBuffer(drmOutput->pixelSize());
 
     EGLAttrib streamAttribs[] = {
         EGL_STREAM_FIFO_LENGTH_KHR, 0, // mailbox mode
         EGL_CONSUMER_AUTO_ACQUIRE_EXT, EGL_FALSE,
         EGL_NONE
     };
     EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs);
     if (stream == EGL_NO_STREAM_KHR) {
         qCCritical(KWIN_DRM) << "Failed to create EGL stream for output";
         return false;
     }
 
     EGLAttrib outputAttribs[3];
     if (drmOutput->primaryPlane()) {
         outputAttribs[0] = EGL_DRM_PLANE_EXT;
         outputAttribs[1] = drmOutput->primaryPlane()->id();
     } else {
         outputAttribs[0] = EGL_DRM_CRTC_EXT;
         outputAttribs[1] = drmOutput->crtc()->id();
     }
     outputAttribs[2] = EGL_NONE;
     EGLint numLayers;
     EGLOutputLayerEXT outputLayer;
     pEglGetOutputLayersEXT(eglDisplay(), outputAttribs, &outputLayer, 1, &numLayers);
     if (numLayers == 0) {
         qCCritical(KWIN_DRM) << "No EGL output layers found";
         return false;
     }
 
     pEglStreamConsumerOutputEXT(eglDisplay(), stream, outputLayer);
     EGLint streamProducerAttribs[] = {
         EGL_WIDTH, drmOutput->pixelSize().width(),
         EGL_HEIGHT, drmOutput->pixelSize().height(),
         EGL_NONE
     };
     EGLSurface eglSurface = pEglCreateStreamProducerSurfaceKHR(eglDisplay(), config(), stream,
                                                                streamProducerAttribs);
     if (eglSurface == EGL_NO_SURFACE) {
         qCCritical(KWIN_DRM) << "Failed to create EGL surface for output";
         return false;
     }
 
     if (o.eglSurface != EGL_NO_SURFACE) {
         if (surface() == o.eglSurface) {
             setSurface(eglSurface);
         }
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
     
     if (o.eglStream != EGL_NO_STREAM_KHR) {
         pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
     }
     
     o.eglStream = stream;
     o.eglSurface = eglSurface;
     return true;
 }
 
 void EglStreamBackend::createOutput(DrmOutput *drmOutput)
 {
     Output o;
     if (!resetOutput(o, drmOutput)) {
         return;
     }
 
     connect(drmOutput, &DrmOutput::modeChanged, this,
         [drmOutput, this] {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [drmOutput] (const auto &o) {
                     return o.output == drmOutput;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             resetOutput(*it, drmOutput);
         }
     );
     m_outputs << o;
 }
 
 bool EglStreamBackend::makeContextCurrent(const Output &output)
 {
     const EGLSurface surface = output.eglSurface;
     if (surface == EGL_NO_SURFACE) {
         return false;
     }
     
     if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
         qCCritical(KWIN_DRM) << "Failed to make EGL context current";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_DRM) << "Error occurred while making EGL context current" << error;
         return false;
     }
     
     const QSize &overall = screens()->size();
     const QRect &v = output.output->geometry();
     qreal scale = output.output->scale();
     glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
                overall.width() * scale, overall.height() * scale);
     return true;
 }
 
 bool EglStreamBackend::initBufferConfigs()
 {
     const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE,         EGL_STREAM_BIT_KHR,
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
     EGLint count;
     EGLConfig config;
     if (!eglChooseConfig(eglDisplay(), configAttribs, &config, 1, &count)) {
         qCCritical(KWIN_DRM) << "Failed to query available EGL configs";
         return false;
     }
     if (count == 0) {
         qCCritical(KWIN_DRM) << "No suitable EGL config found";
         return false;
     }
 
     setConfig(config);
     return true;
 }
 
 void EglStreamBackend::present()
 {
     for (auto &o : m_outputs) {
         makeContextCurrent(o);
         presentOnOutput(o);
     }
 }
 
 void EglStreamBackend::presentOnOutput(EglStreamBackend::Output &o)
 {
     eglSwapBuffers(eglDisplay(), o.eglSurface);
     if (!m_backend->present(o.buffer, o.output)) {
         return;
     }
 
     EGLAttrib acquireAttribs[] = {
         EGL_DRM_FLIP_EVENT_DATA_NV, (EGLAttrib)o.output,
         EGL_NONE,
     };
     if (!pEglStreamConsumerAcquireAttribNV(eglDisplay(), o.eglStream, acquireAttribs)) {
         qCWarning(KWIN_DRM) << "Failed to acquire output EGL stream frame";
     }
 }
 
 void EglStreamBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
 }
 
 SceneOpenGLTexturePrivate *EglStreamBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglStreamTexture(texture, this);
 }
 
 QRegion EglStreamBackend::prepareRenderingFrame()
 {
     startRenderTimer();
     return QRegion();
 }
 
 QRegion EglStreamBackend::prepareRenderingForScreen(int screenId)
 {
     const Output &o = m_outputs.at(screenId);
     makeContextCurrent(o);
     return o.output->geometry();
 }
 
 void EglStreamBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion)
     Q_UNUSED(damagedRegion)
 }
 
 void EglStreamBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion);
     Q_UNUSED(damagedRegion);
     Output &o = m_outputs[screenId];
     presentOnOutput(o);
 }
 
 bool EglStreamBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool EglStreamBackend::perScreenRendering() const
 {
     return true;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglStreamTexture::EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend)
     : AbstractEglTexture(texture, backend), m_backend(backend), m_fbo(0), m_rbo(0)
 {
 }
 
 EglStreamTexture::~EglStreamTexture()
 {
     glDeleteRenderbuffers(1, &m_rbo);
     glDeleteFramebuffers(1, &m_fbo);
 }
 
 bool EglStreamTexture::acquireStreamFrame(EGLStreamKHR stream)
 {
     EGLAttrib streamState;
     if (!pEglQueryStreamAttribNV(m_backend->eglDisplay(), stream,
                                  EGL_STREAM_STATE_KHR, &streamState)) {
         qCWarning(KWIN_DRM) << "Failed to query EGL stream state";
         return false;
     }
 
     if (streamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
         if (pEglStreamConsumerAcquireAttribNV(m_backend->eglDisplay(), stream, nullptr)) {
             return true;
         } else {
             qCWarning(KWIN_DRM) << "Failed to acquire EGL stream frame";
         }
     }
 
     // Re-use previous texture contents if no new frame is available
     // or if acquisition fails for some reason
     return false;
 }
 
 void EglStreamTexture::createFbo()
 {
     glDeleteRenderbuffers(1, &m_rbo);
     glDeleteFramebuffers(1, &m_fbo);
 
     glGenFramebuffers(1, &m_fbo);
     glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     glGenRenderbuffers(1, &m_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
     glRenderbufferStorage(GL_RENDERBUFFER, m_format, m_size.width(), m_size.height());
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 // Renders the contents of the given EXTERNAL_OES texture
 // to the scratch framebuffer, then copies this to m_texture
 void EglStreamTexture::copyExternalTexture(GLuint tex)
 {
     GLint oldViewport[4], oldProgram;
     glGetIntegerv(GL_VIEWPORT, oldViewport);
     glViewport(0, 0, m_size.width(), m_size.height());
     glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgram);
     glUseProgram(0);
     glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
     glEnable(GL_TEXTURE_EXTERNAL_OES);
 
     GLfloat yTop = texture()->isYInverted() ? 0 : 1;
     glBegin(GL_QUADS);
     glTexCoord2f(0, yTop);
     glVertex2f(-1, 1);
     glTexCoord2f(0, 1 - yTop);
     glVertex2f(-1, -1);
     glTexCoord2f(1, 1 - yTop);
     glVertex2f(1, -1);
     glTexCoord2f(1, yTop);
     glVertex2f(1, 1);
     glEnd();
 
     texture()->bind();
     glCopyTexImage2D(m_target, 0, m_format, 0, 0, m_size.width(), m_size.height(), 0);
     texture()->unbind();
 
     glDisable(GL_TEXTURE_EXTERNAL_OES);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
     glBindRenderbuffer(GL_RENDERBUFFER, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
     glUseProgram(oldProgram);
     glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
 }
 
 bool EglStreamTexture::attachBuffer(KWayland::Server::BufferInterface *buffer)
 {
     QSize oldSize = m_size;
     m_size = buffer->size();
     GLenum oldFormat = m_format;
     m_format = buffer->hasAlphaChannel() ? GL_RGBA : GL_RGB;
 
     EGLint yInverted, wasYInverted = texture()->isYInverted();
     if (!pEglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted)) {
         yInverted = EGL_TRUE;
     }
     texture()->setYInverted(yInverted);
     updateMatrix();
 
     return oldSize != m_size ||
            oldFormat != m_format ||
            wasYInverted != texture()->isYInverted();
 }
 
 bool EglStreamTexture::loadTexture(WindowPixmap *pixmap)
 {
     using namespace KWayland::Server;
     SurfaceInterface *surface = pixmap->surface();
     const EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
     if (!pixmap->buffer().isNull() && st != nullptr) {
 
         glGenTextures(1, &m_texture);
         texture()->setWrapMode(GL_CLAMP_TO_EDGE);
         texture()->setFilter(GL_LINEAR);
 
         attachBuffer(surface->buffer());
         createFbo();
         surface->resetTrackedDamage();
 
         if (acquireStreamFrame(st->stream)) {
             copyExternalTexture(st->texture);
             if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
                 qCWarning(KWIN_DRM) << "Failed to release EGL stream";
             }
         }
         return true;
     } else {
         // Not an EGLStream surface
         return AbstractEglTexture::loadTexture(pixmap);
     }
 }
 
 void EglStreamTexture::updateTexture(WindowPixmap *pixmap)
 {
     using namespace KWayland::Server;    
     SurfaceInterface *surface = pixmap->surface();
     const EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
     if (!pixmap->buffer().isNull() && st != nullptr) {
 
         if (attachBuffer(surface->buffer())) {
             createFbo();
         }
         surface->resetTrackedDamage();
 
         if (acquireStreamFrame(st->stream)) {
             copyExternalTexture(st->texture);
             if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
                 qCWarning(KWIN_DRM) << "Failed to release EGL stream";
             }
         }
     } else {
         // Not an EGLStream surface
         AbstractEglTexture::updateTexture(pixmap);
     }
 }
 
 } // namespace
diff --git a/plugins/platforms/hwcomposer/egl_hwcomposer_backend.cpp b/plugins/platforms/hwcomposer/egl_hwcomposer_backend.cpp
index 5207545bd..9d354268c 100644
--- a/plugins/platforms/hwcomposer/egl_hwcomposer_backend.cpp
+++ b/plugins/platforms/hwcomposer/egl_hwcomposer_backend.cpp
@@ -1,188 +1,187 @@
 /********************************************************************
  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 3 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 "egl_hwcomposer_backend.h"
 #include "hwcomposer_backend.h"
 #include "logging.h"
 
 namespace KWin
 {
 
 EglHwcomposerBackend::EglHwcomposerBackend(HwcomposerBackend *backend)
     : AbstractEglBackend()
     , m_backend(backend)
 {
     // EGL is always direct rendering
     setIsDirectRendering(true);
-    setSyncsToVBlank(true);
     setBlocksForRetrace(true);
 }
 
 EglHwcomposerBackend::~EglHwcomposerBackend()
 {
     cleanup();
 }
 
 bool EglHwcomposerBackend::initializeEgl()
 {
     // cannot use initClientExtensions as that crashes in libhybris
     qputenv("EGL_PLATFORM", QByteArrayLiteral("hwcomposer"));
     EGLDisplay display = m_backend->sceneEglDisplay();
 
     if (display == EGL_NO_DISPLAY) {
         display = eglGetDisplay(nullptr);
     }
     if (display == EGL_NO_DISPLAY) {
         return false;
     }
     setEglDisplay(display);
     return initEglAPI();
 }
 
 void EglHwcomposerBackend::init()
 {
     if (!initializeEgl()) {
         setFailed("Failed to initialize egl");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Could not initialize rendering context");
         return;
     }
 
     initKWinGL();
     initBufferAge();
     initWayland();
 }
 
 bool EglHwcomposerBackend::initBufferConfigs()
 {
     const EGLint config_attribs[] = {
         EGL_RED_SIZE,             8,
         EGL_GREEN_SIZE,           8,
         EGL_BLUE_SIZE,            8,
         EGL_ALPHA_SIZE,           8,
         EGL_RENDERABLE_TYPE,      EGL_OPENGL_ES2_BIT,
         EGL_NONE,
     };
 
     EGLint count;
     EGLConfig configs[1024];
     if (eglChooseConfig(eglDisplay(), config_attribs, configs, 1, &count) == EGL_FALSE) {
         qCCritical(KWIN_HWCOMPOSER) << "choose config failed";
         return false;
     }
     if (count != 1) {
         qCCritical(KWIN_HWCOMPOSER) << "choose config did not return a config" << count;
         return false;
     }
     setConfig(configs[0]);
 
     return true;
 }
 
 bool EglHwcomposerBackend::initRenderingContext()
 {
     if (!initBufferConfigs()) {
         return false;
     }
 
     if (!createContext()) {
         return false;
     }
 
     m_nativeSurface = m_backend->createSurface();
     EGLSurface surface = eglCreateWindowSurface(eglDisplay(), config(), (EGLNativeWindowType)static_cast<ANativeWindow*>(m_nativeSurface), nullptr);
     if (surface == EGL_NO_SURFACE) {
         qCCritical(KWIN_HWCOMPOSER) << "Create surface failed";
         return false;
     }
     setSurface(surface);
 
     return makeContextCurrent();
 }
 
 bool EglHwcomposerBackend::makeContextCurrent()
 {
     if (eglMakeCurrent(eglDisplay(), surface(), surface(), context()) == EGL_FALSE) {
         qCCritical(KWIN_HWCOMPOSER) << "Make Context Current failed";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_HWCOMPOSER) << "Error occurred while creating context " << error;
         return false;
     }
 
     const QSize overall = m_backend->size();
     glViewport(0, 0, overall.width(), overall.height());
 
     return true;
 }
 
 void EglHwcomposerBackend::present()
 {
     if (lastDamage().isEmpty()) {
         return;
     }
 
     eglSwapBuffers(eglDisplay(), surface());
     setLastDamage(QRegion());
 }
 
 void EglHwcomposerBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
 }
 
 QRegion EglHwcomposerBackend::prepareRenderingFrame()
 {
     present();
 
     // TODO: buffer age?
     startRenderTimer();
     // triggers always a full repaint
     return QRegion(QRect(QPoint(0, 0), m_backend->size()));
 }
 
 void EglHwcomposerBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(damagedRegion)
     setLastDamage(renderedRegion);
 }
 
 SceneOpenGLTexturePrivate *EglHwcomposerBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglHwcomposerTexture(texture, this);
 }
 
 bool EglHwcomposerBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 EglHwcomposerTexture::EglHwcomposerTexture(SceneOpenGLTexture *texture, EglHwcomposerBackend *backend)
     : AbstractEglTexture(texture, backend)
 {
 }
 
 EglHwcomposerTexture::~EglHwcomposerTexture() = default;
 
 }
diff --git a/plugins/platforms/x11/common/eglonxbackend.cpp b/plugins/platforms/x11/common/eglonxbackend.cpp
index baa9c06ac..f4b8fe8cd 100644
--- a/plugins/platforms/x11/common/eglonxbackend.cpp
+++ b/plugins/platforms/x11/common/eglonxbackend.cpp
@@ -1,497 +1,491 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2010, 2012 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 "eglonxbackend.h"
 // kwin
 #include "main.h"
 #include "options.h"
 #include "overlaywindow.h"
 #include "platform.h"
 #include "scene.h"
 #include "screens.h"
 #include "xcbutils.h"
 #include "texture.h"
 // kwin libs
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 // Qt
 #include <QLoggingCategory>
 #include <QDebug>
 #include <QOpenGLContext>
 // system
 #include <unistd.h>
 
 Q_LOGGING_CATEGORY(KWIN_CORE, "kwin_core", QtCriticalMsg)
 
 namespace KWin
 {
 
 EglOnXBackend::EglOnXBackend(Display *display)
     : AbstractEglBackend()
     , m_overlayWindow(kwinApp()->platform()->createOverlayWindow())
     , surfaceHasSubPost(0)
     , m_bufferAge(0)
     , m_usesOverlayWindow(true)
     , m_connection(connection())
     , m_x11Display(display)
     , m_rootWindow(rootWindow())
     , m_x11ScreenNumber(kwinApp()->x11ScreenNumber())
 {
     // Egl is always direct rendering
     setIsDirectRendering(true);
 }
 
 EglOnXBackend::EglOnXBackend(xcb_connection_t *connection, Display *display, xcb_window_t rootWindow, int screenNumber, xcb_window_t renderingWindow)
     : AbstractEglBackend()
     , m_overlayWindow(nullptr)
     , surfaceHasSubPost(0)
     , m_bufferAge(0)
     , m_usesOverlayWindow(false)
     , m_connection(connection)
     , m_x11Display(display)
     , m_rootWindow(rootWindow)
     , m_x11ScreenNumber(screenNumber)
     , m_renderingWindow(renderingWindow)
 {
     // Egl is always direct rendering
     setIsDirectRendering(true);
 }
 
 EglOnXBackend::~EglOnXBackend()
 {
     if (isFailed() && m_overlayWindow) {
         m_overlayWindow->destroy();
     }
     cleanup();
 
     if (m_overlayWindow) {
         if (overlayWindow()->window()) {
             overlayWindow()->destroy();
         }
         delete m_overlayWindow;
     }
 }
 
 void EglOnXBackend::init()
 {
     qputenv("EGL_PLATFORM", "x11");
     if (!initRenderingContext()) {
         setFailed(QStringLiteral("Could not initialize rendering context"));
         return;
     }
 
     initKWinGL();
     if (!hasExtension(QByteArrayLiteral("EGL_KHR_image")) &&
         (!hasExtension(QByteArrayLiteral("EGL_KHR_image_base")) ||
          !hasExtension(QByteArrayLiteral("EGL_KHR_image_pixmap")))) {
         setFailed(QStringLiteral("Required support for binding pixmaps to EGLImages not found, disabling compositing"));
         return;
     }
     if (!hasGLExtension(QByteArrayLiteral("GL_OES_EGL_image"))) {
         setFailed(QStringLiteral("Required extension GL_OES_EGL_image not found, disabling compositing"));
         return;
     }
 
     // check for EGL_NV_post_sub_buffer and whether it can be used on the surface
     if (hasExtension(QByteArrayLiteral("EGL_NV_post_sub_buffer"))) {
         if (eglQuerySurface(eglDisplay(), surface(), EGL_POST_SUB_BUFFER_SUPPORTED_NV, &surfaceHasSubPost) == EGL_FALSE) {
             EGLint error = eglGetError();
             if (error != EGL_SUCCESS && error != EGL_BAD_ATTRIBUTE) {
                 setFailed(QStringLiteral("query surface failed"));
                 return;
             } else {
                 surfaceHasSubPost = EGL_FALSE;
             }
         }
     }
 
-    setSyncsToVBlank(false);
     setBlocksForRetrace(true);
     if (surfaceHasSubPost) {
         qCDebug(KWIN_CORE) << "EGL implementation and surface support eglPostSubBufferNV, let's use it";
 
-        if (options->glPreferBufferSwap() != Options::NoSwapEncourage) {
-            // check if swap interval 1 is supported
-            EGLint val;
-            eglGetConfigAttrib(eglDisplay(), config(), EGL_MAX_SWAP_INTERVAL, &val);
-            if (val >= 1) {
-                if (eglSwapInterval(eglDisplay(), 1)) {
-                    qCDebug(KWIN_CORE) << "Enabled v-sync";
-                    setSyncsToVBlank(true);
-                }
-            } else {
-                qCWarning(KWIN_CORE) << "Cannot enable v-sync as max. swap interval is" << val;
+        // check if swap interval 1 is supported
+        EGLint val;
+        eglGetConfigAttrib(eglDisplay(), config(), EGL_MAX_SWAP_INTERVAL, &val);
+        if (val >= 1) {
+            if (eglSwapInterval(eglDisplay(), 1)) {
+                qCDebug(KWIN_CORE) << "Enabled v-sync";
             }
         } else {
-            // disable v-sync
-            eglSwapInterval(eglDisplay(), 0);
+            qCWarning(KWIN_CORE) << "Cannot enable v-sync as max. swap interval is" << val;
         }
+
     } else {
         /* In the GLX backend, we fall back to using glCopyPixels if we have no extension providing support for partial screen updates.
          * However, that does not work in EGL - glCopyPixels with glDrawBuffer(GL_FRONT); does nothing.
          * Hence we need EGL to preserve the backbuffer for us, so that we can draw the partial updates on it and call
          * eglSwapBuffers() for each frame. eglSwapBuffers() then does the copy (no page flip possible in this mode),
          * which means it is slow and not synced to the v-blank. */
         qCWarning(KWIN_CORE) << "eglPostSubBufferNV not supported, have to enable buffer preservation - which breaks v-sync and performance";
         eglSurfaceAttrib(eglDisplay(), surface(), EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
     }
 
     initWayland();
 }
 
 bool EglOnXBackend::initRenderingContext()
 {
     initClientExtensions();
     EGLDisplay dpy = kwinApp()->platform()->sceneEglDisplay();
 
     // Use eglGetPlatformDisplayEXT() to get the display pointer
     // if the implementation supports it.
     if (dpy == EGL_NO_DISPLAY) {
         const bool havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
         setHavePlatformBase(havePlatformBase);
         if (havePlatformBase) {
             // Make sure that the X11 platform is supported
             if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_x11")) &&
                 !hasClientExtension(QByteArrayLiteral("EGL_KHR_platform_x11"))) {
                 qCWarning(KWIN_CORE) << "EGL_EXT_platform_base is supported, but neither EGL_EXT_platform_x11 nor EGL_KHR_platform_x11 is supported."
                                      << "Cannot create EGLDisplay on X11";
                 return false;
             }
 
             const int attribs[] = {
                 EGL_PLATFORM_X11_SCREEN_EXT, m_x11ScreenNumber,
                 EGL_NONE
             };
 
             dpy = eglGetPlatformDisplayEXT(EGL_PLATFORM_X11_EXT, m_x11Display, attribs);
         } else {
             dpy = eglGetDisplay(m_x11Display);
         }
     }
 
     if (dpy == EGL_NO_DISPLAY) {
         qCWarning(KWIN_CORE) << "Failed to get the EGLDisplay";
         return false;
     }
     setEglDisplay(dpy);
     initEglAPI();
 
     initBufferConfigs();
 
     if (m_usesOverlayWindow) {
         if (!overlayWindow()->create()) {
             qCCritical(KWIN_CORE) << "Could not get overlay window";
             return false;
         } else {
             overlayWindow()->setup(None);
         }
     }
     if (!createSurfaces()) {
         qCCritical(KWIN_CORE) << "Creating egl surface failed";
         return false;
     }
 
     if (!createContext()) {
         qCCritical(KWIN_CORE) << "Create OpenGL context failed";
         return false;
     }
 
     if (!makeContextCurrent(surface())) {
         qCCritical(KWIN_CORE) << "Make Context Current failed";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_CORE) << "Error occurred while creating context " << error;
         return false;
     }
 
     return true;
 }
 
 bool EglOnXBackend::createSurfaces()
 {
     xcb_window_t window = XCB_WINDOW_NONE;
     if (m_overlayWindow) {
         window = m_overlayWindow->window();
     } else if (m_renderingWindow) {
         window = m_renderingWindow;
     }
 
     EGLSurface surface = createSurface(window);
 
     if (surface == EGL_NO_SURFACE) {
         return false;
     }
     setSurface(surface);
     return true;
 }
 
 EGLSurface EglOnXBackend::createSurface(xcb_window_t window)
 {
     if (window == XCB_WINDOW_NONE) {
         return EGL_NO_SURFACE;
     }
 
     EGLSurface surface = EGL_NO_SURFACE;
     if (havePlatformBase()) {
         // Note: Window is 64 bits on a 64-bit architecture whereas xcb_window_t is
         //       always 32 bits. eglCreatePlatformWindowSurfaceEXT() expects the
         //       native_window parameter to be pointer to a Window, so this variable
         //       cannot be an xcb_window_t.
         surface = eglCreatePlatformWindowSurfaceEXT(eglDisplay(), config(), (void *) &window, nullptr);
     } else {
         surface = eglCreateWindowSurface(eglDisplay(), config(), window, nullptr);
     }
 
     return surface;
 }
 
 bool EglOnXBackend::initBufferConfigs()
 {
     initBufferAge();
     const EGLint config_attribs[] = {
         EGL_SURFACE_TYPE,         EGL_WINDOW_BIT | (supportsBufferAge() ? 0 : EGL_SWAP_BEHAVIOR_PRESERVED_BIT),
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
 
     EGLint count;
     EGLConfig configs[1024];
     if (eglChooseConfig(eglDisplay(), config_attribs, configs, 1024, &count) == EGL_FALSE) {
         qCCritical(KWIN_CORE) << "choose config failed";
         return false;
     }
 
     ScopedCPointer<xcb_get_window_attributes_reply_t> attribs(xcb_get_window_attributes_reply(m_connection,
                                                                                               xcb_get_window_attributes_unchecked(m_connection, m_rootWindow),
                                                                                               nullptr));
     if (!attribs) {
         qCCritical(KWIN_CORE) << "Failed to get window attributes of root window";
         return false;
     }
 
     setConfig(configs[0]);
     for (int i = 0; i < count; i++) {
         EGLint val;
         if (eglGetConfigAttrib(eglDisplay(), configs[i], EGL_NATIVE_VISUAL_ID, &val) == EGL_FALSE) {
             qCCritical(KWIN_CORE) << "egl get config attrib failed";
         }
         if (uint32_t(val) == attribs->visual) {
             setConfig(configs[i]);
             break;
         }
     }
     return true;
 }
 
 void EglOnXBackend::present()
 {
     if (lastDamage().isEmpty())
         return;
 
     presentSurface(surface(), lastDamage(), screens()->geometry());
 
     setLastDamage(QRegion());
     if (!supportsBufferAge()) {
         eglWaitGL();
         xcb_flush(m_connection);
     }
 }
 
 void EglOnXBackend::presentSurface(EGLSurface surface, const QRegion &damage, const QRect &screenGeometry)
 {
     if (damage.isEmpty()) {
         return;
     }
     const bool fullRepaint = supportsBufferAge() || (damage == screenGeometry);
 
     if (fullRepaint || !surfaceHasSubPost) {
         // the entire screen changed, or we cannot do partial updates (which implies we enabled surface preservation)
         eglSwapBuffers(eglDisplay(), surface);
         if (supportsBufferAge()) {
             eglQuerySurface(eglDisplay(), surface, EGL_BUFFER_AGE_EXT, &m_bufferAge);
         }
     } else {
         // a part of the screen changed, and we can use eglPostSubBufferNV to copy the updated area
         for (const QRect &r : damage) {
             eglPostSubBufferNV(eglDisplay(), surface, r.left(), screenGeometry.height() - r.bottom() - 1, r.width(), r.height());
         }
     }
 }
 
 void EglOnXBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
 
     // TODO: base implementation in OpenGLBackend
 
     // The back buffer contents are now undefined
     m_bufferAge = 0;
 }
 
 SceneOpenGLTexturePrivate *EglOnXBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglTexture(texture, this);
 }
 
 QRegion EglOnXBackend::prepareRenderingFrame()
 {
     QRegion repaint;
 
     present();
 
     if (supportsBufferAge())
         repaint = accumulatedDamageHistory(m_bufferAge);
 
     startRenderTimer();
     eglWaitNative(EGL_CORE_NATIVE_ENGINE);
 
     return repaint;
 }
 
 void EglOnXBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     if (damagedRegion.isEmpty()) {
         setLastDamage(QRegion());
 
         // If the damaged region of a window is fully occluded, the only
         // rendering done, if any, will have been to repair a reused back
         // buffer, making it identical to the front buffer.
         //
         // In this case we won't post the back buffer. Instead we'll just
         // set the buffer age to 1, so the repaired regions won't be
         // rendered again in the next frame.
         if (!renderedRegion.isEmpty())
             glFlush();
 
         m_bufferAge = 1;
         return;
     }
 
     setLastDamage(renderedRegion);
 
     if (!blocksForRetrace()) {
         // This also sets lastDamage to empty which prevents the frame from
         // being posted again when prepareRenderingFrame() is called.
         present();
     } else {
         // Make sure that the GPU begins processing the command stream
         // now and not the next time prepareRenderingFrame() is called.
         glFlush();
     }
 
     if (m_overlayWindow && overlayWindow()->window())  // show the window only after the first pass,
         overlayWindow()->show();   // since that pass may take long
 
     // Save the damaged region to history
     if (supportsBufferAge())
         addToDamageHistory(damagedRegion);
 }
 
 bool EglOnXBackend::usesOverlayWindow() const
 {
     return m_usesOverlayWindow;
 }
 
 OverlayWindow* EglOnXBackend::overlayWindow() const
 {
     return m_overlayWindow;
 }
 
 bool EglOnXBackend::makeContextCurrent(const EGLSurface &surface)
 {
     return eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_TRUE;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglTexture::EglTexture(KWin::SceneOpenGLTexture *texture, KWin::EglOnXBackend *backend)
     : AbstractEglTexture(texture, backend)
     , m_backend(backend)
 {
 }
 
 EglTexture::~EglTexture() = default;
 
 bool EglTexture::loadTexture(WindowPixmap *pixmap)
 {
     // first try the Wayland enabled loading
     if (AbstractEglTexture::loadTexture(pixmap)) {
         return true;
     }
     // did not succeed, try on X11
     return loadTexture(pixmap->pixmap(), pixmap->toplevel()->size());
 }
 
 bool EglTexture::loadTexture(xcb_pixmap_t pix, const QSize &size)
 {
     if (!m_backend->isX11TextureFromPixmapSupported()) {
         return false;
     }
 
     if (pix == XCB_NONE)
         return false;
 
     glGenTextures(1, &m_texture);
     auto q = texture();
     q->setWrapMode(GL_CLAMP_TO_EDGE);
     q->setFilter(GL_LINEAR);
     q->bind();
     const EGLint attribs[] = {
         EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
         EGL_NONE
     };
     setImage(eglCreateImageKHR(m_backend->eglDisplay(), EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
                                (EGLClientBuffer)pix, attribs));
 
     if (EGL_NO_IMAGE_KHR == image()) {
         qCDebug(KWIN_CORE) << "failed to create egl image";
         q->unbind();
         q->discard();
         return false;
     }
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image());
     q->unbind();
     q->setYInverted(true);
     m_size = size;
     updateMatrix();
     return true;
 }
 
 void KWin::EglTexture::onDamage()
 {
     if (options->isGlStrictBinding()) {
         // This is just implemented to be consistent with
         // the example in mesa/demos/src/egl/opengles1/texture_from_pixmap.c
         eglWaitNative(EGL_CORE_NATIVE_ENGINE);
         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) image());
     }
     GLTexturePrivate::onDamage();
 }
 
 } // namespace
diff --git a/plugins/platforms/x11/standalone/glxbackend.cpp b/plugins/platforms/x11/standalone/glxbackend.cpp
index 09507c911..fc1f94c58 100644
--- a/plugins/platforms/x11/standalone/glxbackend.cpp
+++ b/plugins/platforms/x11/standalone/glxbackend.cpp
@@ -1,909 +1,891 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 Based on glcompmgr code by Felix Bellaby.
 Using code from Compiz and Beryl.
 
 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/>.
 *********************************************************************/
 
 // own
 #include "glxbackend.h"
 #include "logging.h"
 #include "glx_context_attribute_builder.h"
 // kwin
 #include "options.h"
 #include "overlaywindow.h"
 #include "composite.h"
 #include "platform.h"
 #include "scene.h"
 #include "screens.h"
 #include "xcbutils.h"
 #include "texture.h"
 // kwin libs
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 #include <kwineffectquickview.h>
 #include <kwinxrenderutils.h>
 // Qt
 #include <QDebug>
 #include <QOpenGLContext>
 #include <QX11Info>
 #include <QtPlatformHeaders/QGLXNativeContext>
 // system
 #include <unistd.h>
 
 #include <deque>
 #include <algorithm>
 #if HAVE_DL_LIBRARY
 #include <dlfcn.h>
 #endif
 
 #ifndef XCB_GLX_BUFFER_SWAP_COMPLETE
 #define XCB_GLX_BUFFER_SWAP_COMPLETE 1
 typedef struct xcb_glx_buffer_swap_complete_event_t {
     uint8_t            response_type; /**<  */
     uint8_t            pad0; /**<  */
     uint16_t           sequence; /**<  */
     uint16_t           event_type; /**<  */
     uint8_t            pad1[2]; /**<  */
     xcb_glx_drawable_t drawable; /**<  */
     uint32_t           ust_hi; /**<  */
     uint32_t           ust_lo; /**<  */
     uint32_t           msc_hi; /**<  */
     uint32_t           msc_lo; /**<  */
     uint32_t           sbc; /**<  */
 } xcb_glx_buffer_swap_complete_event_t;
 #endif
 
 #include <tuple>
 #include <memory>
 
 namespace KWin
 {
 
 SwapEventFilter::SwapEventFilter(xcb_drawable_t drawable, xcb_glx_drawable_t glxDrawable)
     : X11EventFilter(Xcb::Extensions::self()->glxEventBase() + XCB_GLX_BUFFER_SWAP_COMPLETE),
       m_drawable(drawable),
       m_glxDrawable(glxDrawable)
 {
 }
 
 bool SwapEventFilter::event(xcb_generic_event_t *event)
 {
     xcb_glx_buffer_swap_complete_event_t *ev =
             reinterpret_cast<xcb_glx_buffer_swap_complete_event_t *>(event);
 
     // The drawable field is the X drawable when the event was synthesized
     // by a WireToEvent handler, and the GLX drawable when the event was
     // received over the wire
     if (ev->drawable == m_drawable || ev->drawable == m_glxDrawable) {
         Compositor::self()->bufferSwapComplete();
         return true;
     }
 
     return false;
 }
 
 
 // -----------------------------------------------------------------------
 
 
 
 GlxBackend::GlxBackend(Display *display)
     : OpenGLBackend()
     , m_overlayWindow(kwinApp()->platform()->createOverlayWindow())
     , window(None)
     , fbconfig(nullptr)
     , glxWindow(None)
     , ctx(nullptr)
     , m_bufferAge(0)
-    , haveSwapInterval(false)
     , m_x11Display(display)
 {
      // Ensures calls to glXSwapBuffers will always block until the next
      // retrace when using the proprietary NVIDIA driver. This must be
      // set before libGL.so is loaded.
      setenv("__GL_MaxFramesAllowed", "1", true);
 
      // Force initialization of GLX integration in the Qt's xcb backend
      // to make it call XESetWireToEvent callbacks, which is required
      // by Mesa when using DRI2.
      QOpenGLContext::supportsThreadedOpenGL();
 }
 
 GlxBackend::~GlxBackend()
 {
     if (isFailed()) {
         m_overlayWindow->destroy();
     }
     // TODO: cleanup in error case
     // do cleanup after initBuffer()
     cleanupGL();
     doneCurrent();
     EffectQuickView::setShareContext(nullptr);
 
     if (ctx)
         glXDestroyContext(display(), ctx);
 
     if (glxWindow)
         glXDestroyWindow(display(), glxWindow);
 
     if (window)
         XDestroyWindow(display(), window);
 
     qDeleteAll(m_fbconfigHash);
     m_fbconfigHash.clear();
 
     overlayWindow()->destroy();
     delete m_overlayWindow;
 }
 
 typedef void (*glXFuncPtr)();
 
 static glXFuncPtr getProcAddress(const char* name)
 {
     glXFuncPtr ret = nullptr;
 #if HAVE_EPOXY_GLX
     ret = glXGetProcAddress((const GLubyte*) name);
 #endif
 #if HAVE_DL_LIBRARY
     if (ret == nullptr)
         ret = (glXFuncPtr) dlsym(RTLD_DEFAULT, name);
 #endif
     return ret;
 }
 glXSwapIntervalMESA_func glXSwapIntervalMESA;
 
 void GlxBackend::init()
 {
     // Require at least GLX 1.3
     if (!checkVersion()) {
         setFailed(QStringLiteral("Requires at least GLX 1.3"));
         return;
     }
 
     initExtensions();
 
     // resolve glXSwapIntervalMESA if available
     if (hasExtension(QByteArrayLiteral("GLX_MESA_swap_control"))) {
         glXSwapIntervalMESA = (glXSwapIntervalMESA_func) getProcAddress("glXSwapIntervalMESA");
     } else {
         glXSwapIntervalMESA = nullptr;
     }
 
     initVisualDepthHashTable();
 
     if (!initBuffer()) {
         setFailed(QStringLiteral("Could not initialize the buffer"));
         return;
     }
 
     if (!initRenderingContext()) {
         setFailed(QStringLiteral("Could not initialize rendering context"));
         return;
     }
 
     // Initialize OpenGL
     GLPlatform *glPlatform = GLPlatform::instance();
     glPlatform->detect(GlxPlatformInterface);
     options->setGlPreferBufferSwap(options->glPreferBufferSwap()); // resolve autosetting
     if (options->glPreferBufferSwap() == Options::AutoSwapStrategy)
         options->setGlPreferBufferSwap('e'); // for unknown drivers - should not happen
     glPlatform->printResults();
     initGL(&getProcAddress);
 
     // Check whether certain features are supported
     m_haveMESACopySubBuffer = hasExtension(QByteArrayLiteral("GLX_MESA_copy_sub_buffer"));
     m_haveMESASwapControl   = hasExtension(QByteArrayLiteral("GLX_MESA_swap_control"));
     m_haveEXTSwapControl    = hasExtension(QByteArrayLiteral("GLX_EXT_swap_control"));
     // only enable Intel swap event if env variable is set, see BUG 342582
     m_haveINTELSwapEvent    = hasExtension(QByteArrayLiteral("GLX_INTEL_swap_event"))
                                 && qgetenv("KWIN_USE_INTEL_SWAP_EVENT") == QByteArrayLiteral("1");
 
     if (m_haveINTELSwapEvent) {
         m_swapEventFilter = std::make_unique<SwapEventFilter>(window, glxWindow);
         glXSelectEvent(display(), glxWindow, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
     }
 
-    haveSwapInterval = m_haveMESASwapControl || m_haveEXTSwapControl;
-
     setSupportsBufferAge(false);
 
     if (hasExtension(QByteArrayLiteral("GLX_EXT_buffer_age"))) {
         const QByteArray useBufferAge = qgetenv("KWIN_USE_BUFFER_AGE");
 
         if (useBufferAge != "0")
             setSupportsBufferAge(true);
     }
 
-    setSyncsToVBlank(false);
     setBlocksForRetrace(true);
-    const bool wantSync = options->glPreferBufferSwap() != Options::NoSwapEncourage;
-    if (wantSync && glXIsDirect(display(), ctx)) {
-        if (haveSwapInterval) { // glXSwapInterval is preferred being more reliable
-            setSwapInterval(1);
-            setSyncsToVBlank(true);
-        } else {
-            qCWarning(KWIN_X11STANDALONE) << "NO VSYNC! glSwapInterval is not supported";
-        }
+
+    if (m_haveEXTSwapControl) {
+        glXSwapIntervalEXT(display(), glxWindow, 1);
+    } else if (m_haveMESASwapControl) {
+        glXSwapIntervalMESA(1);
     } else {
-        // disable v-sync (if possible)
-        setSwapInterval(0);
+        qCWarning(KWIN_X11STANDALONE) << "NO VSYNC! glSwapInterval is not supported";
     }
+
     if (glPlatform->isVirtualBox()) {
         // VirtualBox does not support glxQueryDrawable
         // this should actually be in kwinglutils_funcs, but QueryDrawable seems not to be provided by an extension
         // and the GLPlatform has not been initialized at the moment when initGLX() is called.
         glXQueryDrawable = nullptr;
     }
 
     setIsDirectRendering(bool(glXIsDirect(display(), ctx)));
 
     qCDebug(KWIN_X11STANDALONE) << "Direct rendering:" << isDirectRendering();
 }
 
 bool GlxBackend::checkVersion()
 {
     int major, minor;
     glXQueryVersion(display(), &major, &minor);
     return kVersionNumber(major, minor) >= kVersionNumber(1, 3);
 }
 
 void GlxBackend::initExtensions()
 {
     const QByteArray string = (const char *) glXQueryExtensionsString(display(), QX11Info::appScreen());
     setExtensions(string.split(' '));
 }
 
 bool GlxBackend::initRenderingContext()
 {
     const bool direct = true;
 
     // Use glXCreateContextAttribsARB() when it's available
     if (hasExtension(QByteArrayLiteral("GLX_ARB_create_context"))) {
         const bool have_robustness = hasExtension(QByteArrayLiteral("GLX_ARB_create_context_robustness"));
         const bool haveVideoMemoryPurge = hasExtension(QByteArrayLiteral("GLX_NV_robustness_video_memory_purge"));
 
         std::vector<GlxContextAttributeBuilder> candidates;
         if (options->glCoreProfile()) {
             if (have_robustness) {
                 if (haveVideoMemoryPurge) {
                     GlxContextAttributeBuilder purgeMemoryCore;
                     purgeMemoryCore.setVersion(3, 1);
                     purgeMemoryCore.setRobust(true);
                     purgeMemoryCore.setResetOnVideoMemoryPurge(true);
                     candidates.emplace_back(std::move(purgeMemoryCore));
                 }
                 GlxContextAttributeBuilder robustCore;
                 robustCore.setVersion(3, 1);
                 robustCore.setRobust(true);
                 candidates.emplace_back(std::move(robustCore));
             }
             GlxContextAttributeBuilder core;
             core.setVersion(3, 1);
             candidates.emplace_back(std::move(core));
         } else {
             if (have_robustness) {
                 if (haveVideoMemoryPurge) {
                     GlxContextAttributeBuilder purgeMemoryLegacy;
                     purgeMemoryLegacy.setRobust(true);
                     purgeMemoryLegacy.setResetOnVideoMemoryPurge(true);
                     candidates.emplace_back(std::move(purgeMemoryLegacy));
                 }
                 GlxContextAttributeBuilder robustLegacy;
                 robustLegacy.setRobust(true);
                 candidates.emplace_back(std::move(robustLegacy));
             }
             GlxContextAttributeBuilder legacy;
             legacy.setVersion(2, 1);
             candidates.emplace_back(std::move(legacy));
         }
         for (auto it = candidates.begin(); it != candidates.end(); it++) {
             const auto attribs = it->build();
             ctx = glXCreateContextAttribsARB(display(), fbconfig, nullptr, true, attribs.data());
             if (ctx) {
                 qCDebug(KWIN_X11STANDALONE) << "Created GLX context with attributes:" << &(*it);
                 break;
             }
         }
     }
 
     if (!ctx)
         ctx = glXCreateNewContext(display(), fbconfig, GLX_RGBA_TYPE, nullptr, direct);
 
     if (!ctx) {
         qCDebug(KWIN_X11STANDALONE) << "Failed to create an OpenGL context.";
         return false;
     }
 
     if (!glXMakeCurrent(display(), glxWindow, ctx)) {
         qCDebug(KWIN_X11STANDALONE) << "Failed to make the OpenGL context current.";
         glXDestroyContext(display(), ctx);
         ctx = nullptr;
         return false;
     }
 
     auto qtContext = new QOpenGLContext;
     QGLXNativeContext native(ctx, display());
     qtContext->setNativeHandle(QVariant::fromValue(native));
     qtContext->create();
     EffectQuickView::setShareContext(std::unique_ptr<QOpenGLContext>(qtContext));
 
     return true;
 }
 
 bool GlxBackend::initBuffer()
 {
     if (!initFbConfig())
         return false;
 
     if (overlayWindow()->create()) {
         xcb_connection_t * const c = connection();
 
         // Try to create double-buffered window in the overlay
         xcb_visualid_t visual;
         glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID, (int *) &visual);
 
         if (!visual) {
            qCCritical(KWIN_X11STANDALONE) << "The GLXFBConfig does not have an associated X visual";
            return false;
         }
 
         xcb_colormap_t colormap = xcb_generate_id(c);
         xcb_create_colormap(c, false, colormap, rootWindow(), visual);
 
         const QSize size = screens()->size();
 
         window = xcb_generate_id(c);
         xcb_create_window(c, visualDepth(visual), window, overlayWindow()->window(),
                           0, 0, size.width(), size.height(), 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
                           visual, XCB_CW_COLORMAP, &colormap);
 
         glxWindow = glXCreateWindow(display(), fbconfig, window, nullptr);
         overlayWindow()->setup(window);
     } else {
         qCCritical(KWIN_X11STANDALONE) << "Failed to create overlay window";
         return false;
     }
 
     return true;
 }
 
 bool GlxBackend::initFbConfig()
 {
     const int attribs[] = {
         GLX_RENDER_TYPE,    GLX_RGBA_BIT,
         GLX_DRAWABLE_TYPE,  GLX_WINDOW_BIT,
         GLX_RED_SIZE,       1,
         GLX_GREEN_SIZE,     1,
         GLX_BLUE_SIZE,      1,
         GLX_ALPHA_SIZE,     0,
         GLX_DEPTH_SIZE,     0,
         GLX_STENCIL_SIZE,   0,
         GLX_CONFIG_CAVEAT,  GLX_NONE,
         GLX_DOUBLEBUFFER,   true,
         0
     };
 
     const int attribs_srgb[] = {
         GLX_RENDER_TYPE,                  GLX_RGBA_BIT,
         GLX_DRAWABLE_TYPE,                GLX_WINDOW_BIT,
         GLX_RED_SIZE,                     1,
         GLX_GREEN_SIZE,                   1,
         GLX_BLUE_SIZE,                    1,
         GLX_ALPHA_SIZE,                   0,
         GLX_DEPTH_SIZE,                   0,
         GLX_STENCIL_SIZE,                 0,
         GLX_CONFIG_CAVEAT,                GLX_NONE,
         GLX_DOUBLEBUFFER,                 true,
         GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, true,
         0
     };
 
     bool llvmpipe = false;
 
     // Note that we cannot use GLPlatform::driver() here, because it has not been initialized at this point
     if (hasExtension(QByteArrayLiteral("GLX_MESA_query_renderer"))) {
         const QByteArray device = glXQueryRendererStringMESA(display(), DefaultScreen(display()), 0, GLX_RENDERER_DEVICE_ID_MESA);
         if (device.contains(QByteArrayLiteral("llvmpipe"))) {
             llvmpipe = true;
         }
     }
 
     // Try to find a double buffered sRGB capable configuration
     int count = 0;
     GLXFBConfig *configs = nullptr;
 
     // Don't request an sRGB configuration with LLVMpipe when the default depth is 16. See bug #408594.
     if (!llvmpipe || Xcb::defaultDepth() > 16) {
         configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs_srgb, &count);
     }
 
     if (count == 0) {
         // Try to find a double buffered non-sRGB capable configuration
         configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
     }
 
     struct FBConfig {
         GLXFBConfig config;
         int depth;
         int stencil;
     };
 
     std::deque<FBConfig> candidates;
 
     for (int i = 0; i < count; i++) {
         int depth, stencil;
         glXGetFBConfigAttrib(display(), configs[i], GLX_DEPTH_SIZE,   &depth);
         glXGetFBConfigAttrib(display(), configs[i], GLX_STENCIL_SIZE, &stencil);
 
         candidates.emplace_back(FBConfig{configs[i], depth, stencil});
     }
 
     if (count > 0)
         XFree(configs);
 
     std::stable_sort(candidates.begin(), candidates.end(), [](const FBConfig &left, const FBConfig &right) {
         if (left.depth < right.depth)
             return true;
 
         if (left.stencil < right.stencil)
             return true;
 
         return false;
     });
 
     if (candidates.size() > 0) {
         fbconfig = candidates.front().config;
 
         int fbconfig_id, visual_id, red, green, blue, alpha, depth, stencil, srgb;
         glXGetFBConfigAttrib(display(), fbconfig, GLX_FBCONFIG_ID,  &fbconfig_id);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_VISUAL_ID,    &visual_id);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_RED_SIZE,     &red);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_GREEN_SIZE,   &green);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_BLUE_SIZE,    &blue);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_ALPHA_SIZE,   &alpha);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_DEPTH_SIZE,   &depth);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_STENCIL_SIZE, &stencil);
         glXGetFBConfigAttrib(display(), fbconfig, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgb);
 
         qCDebug(KWIN_X11STANDALONE, "Choosing GLXFBConfig %#x X visual %#x depth %d RGBA %d:%d:%d:%d ZS %d:%d sRGB: %d",
                 fbconfig_id, visual_id, visualDepth(visual_id), red, green, blue, alpha, depth, stencil, srgb);
     }
 
     if (fbconfig == nullptr) {
         qCCritical(KWIN_X11STANDALONE) << "Failed to find a usable framebuffer configuration";
         return false;
     }
 
     return true;
 }
 
 void GlxBackend::initVisualDepthHashTable()
 {
     const xcb_setup_t *setup = xcb_get_setup(connection());
 
     for (auto screen = xcb_setup_roots_iterator(setup); screen.rem; xcb_screen_next(&screen)) {
         for (auto depth = xcb_screen_allowed_depths_iterator(screen.data); depth.rem; xcb_depth_next(&depth)) {
             const int len = xcb_depth_visuals_length(depth.data);
             const xcb_visualtype_t *visuals = xcb_depth_visuals(depth.data);
 
             for (int i = 0; i < len; i++)
                 m_visualDepthHash.insert(visuals[i].visual_id, depth.data->depth);
         }
     }
 }
 
 int GlxBackend::visualDepth(xcb_visualid_t visual) const
 {
     return m_visualDepthHash.value(visual);
 }
 
 static inline int bitCount(uint32_t mask)
 {
 #if defined(__GNUC__)
     return __builtin_popcount(mask);
 #else
     int count = 0;
 
     while (mask) {
         count += (mask & 1);
         mask >>= 1;
     }
 
     return count;
 #endif
 }
 
 FBConfigInfo *GlxBackend::infoForVisual(xcb_visualid_t visual)
 {
     auto it = m_fbconfigHash.constFind(visual);
     if (it != m_fbconfigHash.constEnd()) {
         return it.value();
     }
 
     FBConfigInfo *info = new FBConfigInfo;
     m_fbconfigHash.insert(visual, info);
     info->fbconfig            = nullptr;
     info->bind_texture_format = 0;
     info->texture_targets     = 0;
     info->y_inverted          = 0;
     info->mipmap              = 0;
 
     const xcb_render_pictformat_t format = XRenderUtils::findPictFormat(visual);
     const xcb_render_directformat_t *direct = XRenderUtils::findPictFormatInfo(format);
 
     if (!direct) {
         qCCritical(KWIN_X11STANDALONE).nospace() << "Could not find a picture format for visual 0x" << hex << visual;
         return info;
     }
 
     const int red_bits   = bitCount(direct->red_mask);
     const int green_bits = bitCount(direct->green_mask);
     const int blue_bits  = bitCount(direct->blue_mask);
     const int alpha_bits = bitCount(direct->alpha_mask);
 
     const int depth = visualDepth(visual);
 
     const auto rgb_sizes = std::tie(red_bits, green_bits, blue_bits);
 
     const int attribs[] = {
         GLX_RENDER_TYPE,    GLX_RGBA_BIT,
         GLX_DRAWABLE_TYPE,  GLX_WINDOW_BIT | GLX_PIXMAP_BIT,
         GLX_X_VISUAL_TYPE,  GLX_TRUE_COLOR,
         GLX_X_RENDERABLE,   True,
         GLX_CONFIG_CAVEAT,  int(GLX_DONT_CARE), // The ARGB32 visual is marked non-conformant in Catalyst
         GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT,  int(GLX_DONT_CARE), // The ARGB32 visual is marked sRGB capable in mesa/i965
         GLX_BUFFER_SIZE,    red_bits + green_bits + blue_bits + alpha_bits,
         GLX_RED_SIZE,       red_bits,
         GLX_GREEN_SIZE,     green_bits,
         GLX_BLUE_SIZE,      blue_bits,
         GLX_ALPHA_SIZE,     alpha_bits,
         GLX_STENCIL_SIZE,   0,
         GLX_DEPTH_SIZE,     0,
         0
     };
 
     int count = 0;
     GLXFBConfig *configs = glXChooseFBConfig(display(), DefaultScreen(display()), attribs, &count);
 
     if (count < 1) {
         qCCritical(KWIN_X11STANDALONE).nospace() << "Could not find a framebuffer configuration for visual 0x" << hex << visual;
         return info;
     }
 
     struct FBConfig {
         GLXFBConfig config;
         int depth;
         int stencil;
         int format;
     };
 
     std::deque<FBConfig> candidates;
 
     for (int i = 0; i < count; i++) {
         int red, green, blue;
         glXGetFBConfigAttrib(display(), configs[i], GLX_RED_SIZE,   &red);
         glXGetFBConfigAttrib(display(), configs[i], GLX_GREEN_SIZE, &green);
         glXGetFBConfigAttrib(display(), configs[i], GLX_BLUE_SIZE,  &blue);
 
         if (std::tie(red, green, blue) != rgb_sizes)
             continue;
 
         xcb_visualid_t visual;
         glXGetFBConfigAttrib(display(), configs[i], GLX_VISUAL_ID, (int *) &visual);
 
         if (visualDepth(visual) != depth)
             continue;
 
         int bind_rgb, bind_rgba;
         glXGetFBConfigAttrib(display(), configs[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &bind_rgba);
         glXGetFBConfigAttrib(display(), configs[i], GLX_BIND_TO_TEXTURE_RGB_EXT,  &bind_rgb);
 
         if (!bind_rgb && !bind_rgba)
             continue;
 
         int depth, stencil;
         glXGetFBConfigAttrib(display(), configs[i], GLX_DEPTH_SIZE,   &depth);
         glXGetFBConfigAttrib(display(), configs[i], GLX_STENCIL_SIZE, &stencil);
 
         int texture_format;
         if (alpha_bits)
             texture_format = bind_rgba ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT;
         else
             texture_format = bind_rgb ? GLX_TEXTURE_FORMAT_RGB_EXT : GLX_TEXTURE_FORMAT_RGBA_EXT;
 
         candidates.emplace_back(FBConfig{configs[i], depth, stencil, texture_format});
     }
 
     if (count > 0)
         XFree(configs);
 
     std::stable_sort(candidates.begin(), candidates.end(), [](const FBConfig &left, const FBConfig &right) {
         if (left.depth < right.depth)
             return true;
 
         if (left.stencil < right.stencil)
             return true;
 
         return false;
     });
 
     if (candidates.size() > 0) {
         const FBConfig &candidate = candidates.front();
 
         int y_inverted, texture_targets;
         glXGetFBConfigAttrib(display(), candidate.config, GLX_BIND_TO_TEXTURE_TARGETS_EXT, &texture_targets);
         glXGetFBConfigAttrib(display(), candidate.config, GLX_Y_INVERTED_EXT, &y_inverted);
 
         info->fbconfig            = candidate.config;
         info->bind_texture_format = candidate.format;
         info->texture_targets     = texture_targets;
         info->y_inverted          = y_inverted;
         info->mipmap              = 0;
     }
 
     if (info->fbconfig) {
         int fbc_id = 0;
         int visual_id = 0;
 
         glXGetFBConfigAttrib(display(), info->fbconfig, GLX_FBCONFIG_ID, &fbc_id);
         glXGetFBConfigAttrib(display(), info->fbconfig, GLX_VISUAL_ID,   &visual_id);
 
         qCDebug(KWIN_X11STANDALONE).nospace() << "Using FBConfig 0x" << hex << fbc_id << " for visual 0x" << hex << visual_id;
     }
 
     return info;
 }
 
-void GlxBackend::setSwapInterval(int interval)
-{
-    if (m_haveEXTSwapControl)
-        glXSwapIntervalEXT(display(), glxWindow, interval);
-    else if (m_haveMESASwapControl)
-        glXSwapIntervalMESA(interval);
-}
-
 void GlxBackend::present()
 {
     if (lastDamage().isEmpty())
         return;
 
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     const bool fullRepaint = supportsBufferAge() || (lastDamage() == displayRegion);
 
     if (fullRepaint) {
         if (m_haveINTELSwapEvent)
             Compositor::self()->aboutToSwapBuffers();
 
-        if (haveSwapInterval) {
-            glXSwapBuffers(display(), glxWindow);
-        } else {
-            glXSwapBuffers(display(), glxWindow);
-        }
+        glXSwapBuffers(display(), glxWindow);
+
         if (supportsBufferAge()) {
             glXQueryDrawable(display(), glxWindow, GLX_BACK_BUFFER_AGE_EXT, (GLuint *) &m_bufferAge);
         }
     } else if (m_haveMESACopySubBuffer) {
         for (const QRect &r : lastDamage()) {
             // convert to OpenGL coordinates
             int y = screenSize.height() - r.y() - r.height();
             glXCopySubBufferMESA(display(), glxWindow, r.x(), y, r.width(), r.height());
         }
     } else { // Copy Pixels (horribly slow on Mesa)
         glDrawBuffer(GL_FRONT);
         copyPixels(lastDamage());
         glDrawBuffer(GL_BACK);
     }
 
     setLastDamage(QRegion());
     if (!supportsBufferAge()) {
         glXWaitGL();
         XFlush(display());
     }
 }
 
 void GlxBackend::screenGeometryChanged(const QSize &size)
 {
     doneCurrent();
 
     XMoveResizeWindow(display(), window, 0, 0, size.width(), size.height());
     overlayWindow()->setup(window);
     Xcb::sync();
 
     makeCurrent();
     glViewport(0, 0, size.width(), size.height());
 
     // The back buffer contents are now undefined
     m_bufferAge = 0;
 }
 
 SceneOpenGLTexturePrivate *GlxBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new GlxTexture(texture, this);
 }
 
 QRegion GlxBackend::prepareRenderingFrame()
 {
     QRegion repaint;
 
     present();
 
     if (supportsBufferAge())
         repaint = accumulatedDamageHistory(m_bufferAge);
 
     startRenderTimer();
     glXWaitX();
 
     return repaint;
 }
 
 void GlxBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     if (damagedRegion.isEmpty()) {
         setLastDamage(QRegion());
 
         // If the damaged region of a window is fully occluded, the only
         // rendering done, if any, will have been to repair a reused back
         // buffer, making it identical to the front buffer.
         //
         // In this case we won't post the back buffer. Instead we'll just
         // set the buffer age to 1, so the repaired regions won't be
         // rendered again in the next frame.
         if (!renderedRegion.isEmpty())
             glFlush();
 
         m_bufferAge = 1;
         return;
     }
 
     setLastDamage(renderedRegion);
 
     if (!blocksForRetrace()) {
         // This also sets lastDamage to empty which prevents the frame from
         // being posted again when prepareRenderingFrame() is called.
         present();
     } else {
         // Make sure that the GPU begins processing the command stream
         // now and not the next time prepareRenderingFrame() is called.
         glFlush();
     }
 
     if (overlayWindow()->window())  // show the window only after the first pass,
         overlayWindow()->show();   // since that pass may take long
 
     // Save the damaged region to history
     if (supportsBufferAge())
         addToDamageHistory(damagedRegion);
 }
 
 bool GlxBackend::makeCurrent()
 {
     if (QOpenGLContext *context = QOpenGLContext::currentContext()) {
         // Workaround to tell Qt that no QOpenGLContext is current
         context->doneCurrent();
     }
     const bool current = glXMakeCurrent(display(), glxWindow, ctx);
     return current;
 }
 
 void GlxBackend::doneCurrent()
 {
     glXMakeCurrent(display(), None, nullptr);
 }
 
 OverlayWindow* GlxBackend::overlayWindow() const
 {
     return m_overlayWindow;
 }
 
 bool GlxBackend::usesOverlayWindow() const
 {
     return true;
 }
 
 /********************************************************
  * GlxTexture
  *******************************************************/
 GlxTexture::GlxTexture(SceneOpenGLTexture *texture, GlxBackend *backend)
     : SceneOpenGLTexturePrivate()
     , q(texture)
     , m_backend(backend)
     , m_glxpixmap(None)
 {
 }
 
 GlxTexture::~GlxTexture()
 {
     if (m_glxpixmap != None) {
         if (!options->isGlStrictBinding()) {
             glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
         }
         glXDestroyPixmap(display(), m_glxpixmap);
         m_glxpixmap = None;
     }
 }
 
 void GlxTexture::onDamage()
 {
     if (options->isGlStrictBinding() && m_glxpixmap) {
         glXReleaseTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT);
         glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, nullptr);
     }
     GLTexturePrivate::onDamage();
 }
 
 bool GlxTexture::loadTexture(xcb_pixmap_t pixmap, const QSize &size, xcb_visualid_t visual)
 {
     if (pixmap == XCB_NONE || size.isEmpty() || visual == XCB_NONE)
         return false;
 
     const FBConfigInfo *info = m_backend->infoForVisual(visual);
     if (!info || info->fbconfig == nullptr)
         return false;
 
     if (info->texture_targets & GLX_TEXTURE_2D_BIT_EXT) {
         m_target = GL_TEXTURE_2D;
         m_scale.setWidth(1.0f / m_size.width());
         m_scale.setHeight(1.0f / m_size.height());
     } else {
         Q_ASSERT(info->texture_targets & GLX_TEXTURE_RECTANGLE_BIT_EXT);
 
         m_target = GL_TEXTURE_RECTANGLE;
         m_scale.setWidth(1.0f);
         m_scale.setHeight(1.0f);
     }
 
     const int attrs[] = {
         GLX_TEXTURE_FORMAT_EXT, info->bind_texture_format,
         GLX_MIPMAP_TEXTURE_EXT, false,
         GLX_TEXTURE_TARGET_EXT, m_target == GL_TEXTURE_2D ? GLX_TEXTURE_2D_EXT : GLX_TEXTURE_RECTANGLE_EXT,
         0
     };
 
     m_glxpixmap     = glXCreatePixmap(display(), info->fbconfig, pixmap, attrs);
     m_size          = size;
     m_yInverted     = info->y_inverted ? true : false;
     m_canUseMipmaps = false;
 
     glGenTextures(1, &m_texture);
 
     q->setDirty();
     q->setFilter(GL_NEAREST);
 
     glBindTexture(m_target, m_texture);
     glXBindTexImageEXT(display(), m_glxpixmap, GLX_FRONT_LEFT_EXT, nullptr);
 
     updateMatrix();
     return true;
 }
 
 bool GlxTexture::loadTexture(WindowPixmap *pixmap)
 {
     Toplevel *t = pixmap->toplevel();
     return loadTexture(pixmap->pixmap(), t->size(), t->visual());
 }
 
 OpenGLBackend *GlxTexture::backend()
 {
     return m_backend;
 }
 
 } // namespace
diff --git a/plugins/platforms/x11/standalone/glxbackend.h b/plugins/platforms/x11/standalone/glxbackend.h
index ec55ac49b..d72dda865 100644
--- a/plugins/platforms/x11/standalone/glxbackend.h
+++ b/plugins/platforms/x11/standalone/glxbackend.h
@@ -1,145 +1,143 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 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_GLX_BACKEND_H
 #define KWIN_GLX_BACKEND_H
 #include "backend.h"
 #include "texture.h"
 #include "x11eventfilter.h"
 
 #include <xcb/glx.h>
 #include <epoxy/glx.h>
 #include <fixx11h.h>
 #include <memory>
 
 namespace KWin
 {
 
 // GLX_MESA_swap_interval
 using glXSwapIntervalMESA_func = int (*)(unsigned int interval);
 extern glXSwapIntervalMESA_func glXSwapIntervalMESA;
 
 class FBConfigInfo
 {
 public:
     GLXFBConfig fbconfig;
     int bind_texture_format;
     int texture_targets;
     int y_inverted;
     int mipmap;
 };
 
 
 // ------------------------------------------------------------------
 
 
 class SwapEventFilter : public X11EventFilter
 {
 public:
     SwapEventFilter(xcb_drawable_t drawable, xcb_glx_drawable_t glxDrawable);
     bool event(xcb_generic_event_t *event) override;
 
 private:
     xcb_drawable_t m_drawable;
     xcb_glx_drawable_t m_glxDrawable;
 };
 
 
 /**
  * @brief OpenGL Backend using GLX over an X overlay window.
  */
 class GlxBackend : public OpenGLBackend
 {
 public:
     GlxBackend(Display *display);
     ~GlxBackend() override;
     void screenGeometryChanged(const QSize &size) override;
     SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) override;
     QRegion prepareRenderingFrame() override;
     void endRenderingFrame(const QRegion &damage, const QRegion &damagedRegion) override;
     bool makeCurrent() override;
     void doneCurrent() override;
     OverlayWindow* overlayWindow() const override;
     bool usesOverlayWindow() const override;
     void init() override;
 
 protected:
     void present() override;
 
 private:
     bool initBuffer();
     bool checkVersion();
     void initExtensions();
     bool initRenderingContext();
     bool initFbConfig();
     void initVisualDepthHashTable();
-    void setSwapInterval(int interval);
     Display *display() const {
         return m_x11Display;
     }
 
     int visualDepth(xcb_visualid_t visual) const;
     FBConfigInfo *infoForVisual(xcb_visualid_t visual);
 
     /**
      * @brief The OverlayWindow used by this Backend.
      */
     OverlayWindow *m_overlayWindow;
     Window window;
     GLXFBConfig fbconfig;
     GLXWindow glxWindow;
     GLXContext ctx;
     QHash<xcb_visualid_t, FBConfigInfo *> m_fbconfigHash;
     QHash<xcb_visualid_t, int> m_visualDepthHash;
     std::unique_ptr<SwapEventFilter> m_swapEventFilter;
     int m_bufferAge;
     bool m_haveMESACopySubBuffer = false;
     bool m_haveMESASwapControl = false;
     bool m_haveEXTSwapControl = false;
     bool m_haveINTELSwapEvent = false;
-    bool haveSwapInterval = false;
     Display *m_x11Display;
     friend class GlxTexture;
 };
 
 /**
  * @brief Texture using an GLXPixmap.
  */
 class GlxTexture : public SceneOpenGLTexturePrivate
 {
 public:
     ~GlxTexture() override;
     void onDamage() override;
     bool loadTexture(WindowPixmap *pixmap) override;
     OpenGLBackend *backend() override;
 
 private:
     friend class GlxBackend;
     GlxTexture(SceneOpenGLTexture *texture, GlxBackend *backend);
     bool loadTexture(xcb_pixmap_t pix, const QSize &size, xcb_visualid_t visual);
     Display *display() const {
         return m_backend->m_x11Display;
     }
     SceneOpenGLTexture *q;
     GlxBackend *m_backend;
     GLXPixmap m_glxpixmap; // the glx pixmap the texture is bound to
 };
 
 } // namespace
 #endif // KWIN_GLX_BACKEND_H
diff --git a/plugins/scenes/opengl/scene_opengl.cpp b/plugins/scenes/opengl/scene_opengl.cpp
index d566a8bd2..0945cbd38 100644
--- a/plugins/scenes/opengl/scene_opengl.cpp
+++ b/plugins/scenes/opengl/scene_opengl.cpp
@@ -1,2640 +1,2635 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 Based on glcompmgr code by Felix Bellaby.
 Using code from Compiz and Beryl.
 
 Explicit command stream synchronization based on the sample
 implementation by James Jones <jajones@nvidia.com>,
 
 Copyright © 2011 NVIDIA Corporation
 
 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 "scene_opengl.h"
 
 #include "platform.h"
 #include "wayland_server.h"
 #include "platformsupport/scenes/opengl/texture.h"
 
 #include <kwinglplatform.h>
 #include <kwineffectquickview.h>
 
 #include "utils.h"
 #include "x11client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effects.h"
 #include "lanczosfilter.h"
 #include "main.h"
 #include "overlaywindow.h"
 #include "screens.h"
 #include "cursor.h"
 #include "decorations/decoratedclient.h"
 #include <logging.h>
 
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/subcompositor_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include <array>
 #include <cmath>
 #include <cstddef>
 #include <unistd.h>
 
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusInterface>
 #include <QGraphicsScale>
 #include <QPainter>
 #include <QStringList>
 #include <QVector2D>
 #include <QVector4D>
 #include <QMatrix4x4>
 
 #include <KLocalizedString>
 #include <KNotification>
 #include <KProcess>
 
 // HACK: workaround for libepoxy < 1.3
 #ifndef GL_GUILTY_CONTEXT_RESET
 #define GL_GUILTY_CONTEXT_RESET 0x8253
 #endif
 #ifndef GL_INNOCENT_CONTEXT_RESET
 #define GL_INNOCENT_CONTEXT_RESET 0x8254
 #endif
 #ifndef GL_UNKNOWN_CONTEXT_RESET
 #define GL_UNKNOWN_CONTEXT_RESET 0x8255
 #endif
 
 namespace KWin
 {
 
 extern int currentRefreshRate();
 
 
 /**
  * SyncObject represents a fence used to synchronize operations in
  * the kwin command stream with operations in the X command stream.
  */
 class SyncObject
 {
 public:
     enum State { Ready, TriggerSent, Waiting, Done, Resetting };
 
     SyncObject();
     ~SyncObject();
 
     State state() const { return m_state; }
 
     void trigger();
     void wait();
     bool finish();
     void reset();
     void finishResetting();
 
 private:
     State m_state;
     GLsync m_sync;
     xcb_sync_fence_t m_fence;
     xcb_get_input_focus_cookie_t m_reset_cookie;
 };
 
 SyncObject::SyncObject()
 {
     m_state = Ready;
 
     xcb_connection_t * const c = connection();
 
     m_fence = xcb_generate_id(c);
     xcb_sync_create_fence(c, rootWindow(), m_fence, false);
     xcb_flush(c);
 
     m_sync = glImportSyncEXT(GL_SYNC_X11_FENCE_EXT, m_fence, 0);
 }
 
 SyncObject::~SyncObject()
 {
     // If glDeleteSync is called before the xcb fence is signalled
     // the nvidia driver (the only one to implement GL_SYNC_X11_FENCE_EXT)
     // deadlocks waiting for the fence to be signalled.
     // To avoid this, make sure the fence is signalled before
     // deleting the sync.
     if (m_state == Resetting || m_state == Ready){
         trigger();
         // The flush is necessary!
         // The trigger command needs to be sent to the X server.
         xcb_flush(connection());
     }
     xcb_sync_destroy_fence(connection(), m_fence);
     glDeleteSync(m_sync);
 
     if (m_state == Resetting)
         xcb_discard_reply(connection(), m_reset_cookie.sequence);
 }
 
 void SyncObject::trigger()
 {
     Q_ASSERT(m_state == Ready || m_state == Resetting);
 
     // Finish resetting the fence if necessary
     if (m_state == Resetting)
         finishResetting();
 
     xcb_sync_trigger_fence(connection(), m_fence);
     m_state = TriggerSent;
 }
 
 void SyncObject::wait()
 {
     if (m_state != TriggerSent)
         return;
 
     glWaitSync(m_sync, 0, GL_TIMEOUT_IGNORED);
     m_state = Waiting;
 }
 
 bool SyncObject::finish()
 {
     if (m_state == Done)
         return true;
 
     // Note: It is possible that we never inserted a wait for the fence.
     //       This can happen if we ended up not rendering the damaged
     //       window because it is fully occluded.
     Q_ASSERT(m_state == TriggerSent || m_state == Waiting);
 
     // Check if the fence is signaled
     GLint value;
     glGetSynciv(m_sync, GL_SYNC_STATUS, 1, nullptr, &value);
 
     if (value != GL_SIGNALED) {
         qCDebug(KWIN_OPENGL) << "Waiting for X fence to finish";
 
         // Wait for the fence to become signaled with a one second timeout
         const GLenum result = glClientWaitSync(m_sync, 0, 1000000000);
 
         switch (result) {
         case GL_TIMEOUT_EXPIRED:
             qCWarning(KWIN_OPENGL) << "Timeout while waiting for X fence";
             return false;
 
         case GL_WAIT_FAILED:
             qCWarning(KWIN_OPENGL) << "glClientWaitSync() failed";
             return false;
         }
     }
 
     m_state = Done;
     return true;
 }
 
 void SyncObject::reset()
 {
     Q_ASSERT(m_state == Done);
 
     xcb_connection_t * const c = connection();
 
     // Send the reset request along with a sync request.
     // We use the cookie to ensure that the server has processed the reset
     // request before we trigger the fence and call glWaitSync().
     // Otherwise there is a race condition between the reset finishing and
     // the glWaitSync() call.
     xcb_sync_reset_fence(c, m_fence);
     m_reset_cookie = xcb_get_input_focus(c);
     xcb_flush(c);
 
     m_state = Resetting;
 }
 
 void SyncObject::finishResetting()
 {
     Q_ASSERT(m_state == Resetting);
     free(xcb_get_input_focus_reply(connection(), m_reset_cookie, nullptr));
     m_state = Ready;
 }
 
 
 
 // -----------------------------------------------------------------------
 
 
 
 /**
  * SyncManager manages a set of fences used for explicit synchronization
  * with the X command stream.
  */
 class SyncManager
 {
 public:
     enum { MaxFences = 4 };
 
     SyncManager();
     ~SyncManager();
 
     SyncObject *nextFence();
     bool updateFences();
 
 private:
     std::array<SyncObject, MaxFences> m_fences;
     int m_next;
 };
 
 SyncManager::SyncManager()
     : m_next(0)
 {
 }
 
 SyncManager::~SyncManager()
 {
 }
 
 SyncObject *SyncManager::nextFence()
 {
     SyncObject *fence = &m_fences[m_next];
     m_next = (m_next + 1) % MaxFences;
     return fence;
 }
 
 bool SyncManager::updateFences()
 {
     for (int i = 0; i < qMin(2, MaxFences - 1); i++) {
         const int index = (m_next + i) % MaxFences;
         SyncObject &fence = m_fences[index];
 
         switch (fence.state()) {
         case SyncObject::Ready:
             break;
 
         case SyncObject::TriggerSent:
         case SyncObject::Waiting:
             if (!fence.finish())
                 return false;
             fence.reset();
             break;
 
         // Should not happen in practice since we always reset the fence
         // after finishing it
         case SyncObject::Done:
             fence.reset();
             break;
 
         case SyncObject::Resetting:
             fence.finishResetting();
             break;
         }
     }
 
     return true;
 }
 
 
 // -----------------------------------------------------------------------
 
 /************************************************
  * SceneOpenGL
  ***********************************************/
 
 SceneOpenGL::SceneOpenGL(OpenGLBackend *backend, QObject *parent)
     : Scene(parent)
     , init_ok(true)
     , m_backend(backend)
     , m_syncManager(nullptr)
     , m_currentFence(nullptr)
 {
     if (m_backend->isFailed()) {
         init_ok = false;
         return;
     }
     if (!viewportLimitsMatched(screens()->size()))
         return;
 
     // perform Scene specific checks
     GLPlatform *glPlatform = GLPlatform::instance();
     if (!glPlatform->isGLES() && !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"))
             && !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_rectangle"))) {
         qCCritical(KWIN_OPENGL) << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing";
         init_ok = false;
         return; // error
     }
     if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(10, 0)) {
         qCCritical(KWIN_OPENGL) << "KWin requires at least Mesa 10.0 for OpenGL compositing.";
         init_ok = false;
         return;
     }
     if (!glPlatform->isGLES() && !m_backend->isSurfaceLessContext()) {
         glDrawBuffer(GL_BACK);
     }
 
     m_debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 0;
     initDebugOutput();
 
     // set strict binding
     if (options->isGlStrictBindingFollowsDriver()) {
         options->setGlStrictBinding(!glPlatform->supports(LooseBinding));
     }
 
     bool haveSyncObjects = glPlatform->isGLES()
         ? hasGLVersion(3, 0)
         : hasGLVersion(3, 2) || hasGLExtension("GL_ARB_sync");
 
     if (hasGLExtension("GL_EXT_x11_sync_object") && haveSyncObjects && kwinApp()->operationMode() == Application::OperationModeX11) {
         const QByteArray useExplicitSync = qgetenv("KWIN_EXPLICIT_SYNC");
 
         if (useExplicitSync != "0") {
             qCDebug(KWIN_OPENGL) << "Initializing fences for synchronization with the X command stream";
             m_syncManager = new SyncManager;
         } else {
             qCDebug(KWIN_OPENGL) << "Explicit synchronization with the X command stream disabled by environment variable";
         }
     }
 }
 
 static SceneOpenGL *gs_debuggedScene = nullptr;
 SceneOpenGL::~SceneOpenGL()
 {
     // do cleanup after initBuffer()
     gs_debuggedScene = nullptr;
 
     if (init_ok) {
         makeOpenGLContextCurrent();
     }
     SceneOpenGL::EffectFrame::cleanup();
 
     delete m_syncManager;
 
     // backend might be still needed for a different scene
     delete m_backend;
 }
 
 static void scheduleVboReInit()
 {
     if (!gs_debuggedScene)
         return;
 
     static QPointer<QTimer> timer;
     if (!timer) {
         delete timer;
         timer = new QTimer(gs_debuggedScene);
         timer->setSingleShot(true);
         QObject::connect(timer.data(), &QTimer::timeout, gs_debuggedScene, []() {
             GLVertexBuffer::cleanup();
             GLVertexBuffer::initStatic();
         });
     }
     timer->start(250);
 }
 
 void SceneOpenGL::initDebugOutput()
 {
     const bool have_KHR_debug = hasGLExtension(QByteArrayLiteral("GL_KHR_debug"));
     const bool have_ARB_debug = hasGLExtension(QByteArrayLiteral("GL_ARB_debug_output"));
     if (!have_KHR_debug && !have_ARB_debug)
         return;
 
     if (!have_ARB_debug) {
         // if we don't have ARB debug, but only KHR debug we need to verify whether the context is a debug context
         // it should work without as well, but empirical tests show: no it doesn't
         if (GLPlatform::instance()->isGLES()) {
             if (!hasGLVersion(3, 2)) {
                 // empirical data shows extension doesn't work
                 return;
             }
         } else if (!hasGLVersion(3, 0)) {
             return;
         }
         // can only be queried with either OpenGL >= 3.0 or OpenGL ES of at least 3.1
         GLint value = 0;
         glGetIntegerv(GL_CONTEXT_FLAGS, &value);
         if (!(value & GL_CONTEXT_FLAG_DEBUG_BIT)) {
             return;
         }
     }
 
     gs_debuggedScene = this;
 
     // Set the callback function
     auto callback = [](GLenum source, GLenum type, GLuint id,
                        GLenum severity, GLsizei length,
                        const GLchar *message,
                        const GLvoid *userParam) {
         Q_UNUSED(source)
         Q_UNUSED(severity)
         Q_UNUSED(userParam)
         while (message[length] == '\n' || message[length] == '\r')
             --length;
 
         switch (type) {
         case GL_DEBUG_TYPE_ERROR:
         case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
             qCWarning(KWIN_OPENGL, "%#x: %.*s", id, length, message);
             break;
 
         case GL_DEBUG_TYPE_OTHER:
             // at least the nvidia driver seems prone to end up with invalid VBOs after
             // transferring them between system heap and VRAM
             // so we re-init them whenever this happens (typically when switching VT, resuming
             // from STR and XRandR events - #344326
             if (strstr(message, "Buffer detailed info:") && strstr(message, "has been updated"))
                 scheduleVboReInit();
             // fall through! for general message printing
             Q_FALLTHROUGH();
         case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
         case GL_DEBUG_TYPE_PORTABILITY:
         case GL_DEBUG_TYPE_PERFORMANCE:
         default:
             qCDebug(KWIN_OPENGL, "%#x: %.*s", id, length, message);
             break;
         }
     };
 
     glDebugMessageCallback(callback, nullptr);
 
     // This state exists only in GL_KHR_debug
     if (have_KHR_debug)
         glEnable(GL_DEBUG_OUTPUT);
 
 #if !defined(QT_NO_DEBUG)
     // Enable all debug messages
     glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 #else
     // Enable error messages
     glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_ERROR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
     glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 #endif
 
     // Insert a test message
     const QByteArray message = QByteArrayLiteral("OpenGL debug output initialized");
     glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0,
                          GL_DEBUG_SEVERITY_LOW, message.length(), message.constData());
 }
 
 SceneOpenGL *SceneOpenGL::createScene(QObject *parent)
 {
     OpenGLBackend *backend = kwinApp()->platform()->createOpenGLBackend();
     if (!backend) {
         return nullptr;
     }
     if (!backend->isFailed()) {
         backend->init();
     }
     if (backend->isFailed()) {
         delete backend;
         return nullptr;
     }
     SceneOpenGL *scene = nullptr;
     // first let's try an OpenGL 2 scene
     if (SceneOpenGL2::supported(backend)) {
         scene = new SceneOpenGL2(backend, parent);
         if (scene->initFailed()) {
             delete scene;
             scene = nullptr;
         } else {
             return scene;
         }
     }
     if (!scene) {
         if (GLPlatform::instance()->recommendedCompositor() == XRenderCompositing) {
             qCCritical(KWIN_OPENGL) << "OpenGL driver recommends XRender based compositing. Falling back to XRender.";
             qCCritical(KWIN_OPENGL) << "To overwrite the detection use the environment variable KWIN_COMPOSE";
             qCCritical(KWIN_OPENGL) << "For more information see https://community.kde.org/KWin/Environment_Variables#KWIN_COMPOSE";
         }
         delete backend;
     }
 
     return scene;
 }
 
 OverlayWindow *SceneOpenGL::overlayWindow() const
 {
     return m_backend->overlayWindow();
 }
 
-bool SceneOpenGL::syncsToVBlank() const
-{
-    return m_backend->syncsToVBlank();
-}
-
 bool SceneOpenGL::blocksForRetrace() const
 {
     return m_backend->blocksForRetrace();
 }
 
 void SceneOpenGL::idle()
 {
     m_backend->idle();
     Scene::idle();
 }
 
 bool SceneOpenGL::initFailed() const
 {
     return !init_ok;
 }
 
 void SceneOpenGL::handleGraphicsReset(GLenum status)
 {
     switch (status) {
     case GL_GUILTY_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset attributable to the current GL context occurred.";
         break;
 
     case GL_INNOCENT_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset not attributable to the current GL context occurred.";
         break;
 
     case GL_UNKNOWN_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset of an unknown cause occurred.";
         break;
 
     default:
         break;
     }
 
     QElapsedTimer timer;
     timer.start();
 
     // Wait until the reset is completed or max 10 seconds
     while (timer.elapsed() < 10000 && glGetGraphicsResetStatus() != GL_NO_ERROR)
         usleep(50);
 
     qCDebug(KWIN_OPENGL) << "Attempting to reset compositing.";
     QMetaObject::invokeMethod(this, "resetCompositing", Qt::QueuedConnection);
 
     KNotification::event(QStringLiteral("graphicsreset"), i18n("Desktop effects were restarted due to a graphics reset"));
 }
 
 
 void SceneOpenGL::triggerFence()
 {
     if (m_syncManager) {
         m_currentFence = m_syncManager->nextFence();
         m_currentFence->trigger();
     }
 }
 
 void SceneOpenGL::insertWait()
 {
     if (m_currentFence && m_currentFence->state() != SyncObject::Waiting) {
         m_currentFence->wait();
     }
 }
 
 /**
  * Render cursor texture in case hardware cursor is disabled.
  * Useful for screen recording apps or backends that can't do planes.
  */
 void SceneOpenGL2::paintCursor()
 {
     // don't paint if we use hardware cursor or the cursor is hidden
     if (!kwinApp()->platform()->usesSoftwareCursor() ||
         kwinApp()->platform()->isCursorHidden() ||
         kwinApp()->platform()->softwareCursor().isNull()) {
         return;
     }
 
     // lazy init texture cursor only in case we need software rendering
     if (!m_cursorTexture) {
         auto updateCursorTexture = [this] {
             // don't paint if no image for cursor is set
             const QImage img = kwinApp()->platform()->softwareCursor();
             if (img.isNull()) {
                 return;
             }
             m_cursorTexture.reset(new GLTexture(img));
         };
 
         // init now
         updateCursorTexture();
 
         // handle shape update on case cursor image changed
         connect(kwinApp()->platform(), &Platform::cursorChanged, this, updateCursorTexture);
     }
 
     // get cursor position in projection coordinates
     const QPoint cursorPos = Cursor::pos() - kwinApp()->platform()->softwareCursorHotspot();
     const QRect cursorRect(0, 0, m_cursorTexture->width(), m_cursorTexture->height());
     QMatrix4x4 mvp = m_projectionMatrix;
     mvp.translate(cursorPos.x(), cursorPos.y());
 
     // handle transparence
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     // paint texture in cursor offset
     m_cursorTexture->bind();
     ShaderBinder binder(ShaderTrait::MapTexture);
     binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
     m_cursorTexture->render(QRegion(cursorRect), cursorRect);
     m_cursorTexture->unbind();
 
     kwinApp()->platform()->markCursorAsRendered();
 
     glDisable(GL_BLEND);
 }
 
 qint64 SceneOpenGL::paint(QRegion damage, ToplevelList toplevels)
 {
     // actually paint the frame, flushed with the NEXT frame
     createStackingOrder(toplevels);
 
     // After this call, updateRegion will contain the damaged region in the
     // back buffer. This is the region that needs to be posted to repair
     // the front buffer. It doesn't include the additional damage returned
     // by prepareRenderingFrame(). validRegion is the region that has been
     // repainted, and may be larger than updateRegion.
     QRegion updateRegion, validRegion;
     if (m_backend->perScreenRendering()) {
         // trigger start render timer
         m_backend->prepareRenderingFrame();
         for (int i = 0; i < screens()->count(); ++i) {
             const QRect &geo = screens()->geometry(i);
             QRegion update;
             QRegion valid;
             // prepare rendering makes context current on the output
             QRegion repaint = m_backend->prepareRenderingForScreen(i);
             GLVertexBuffer::setVirtualScreenGeometry(geo);
             GLRenderTarget::setVirtualScreenGeometry(geo);
             GLVertexBuffer::setVirtualScreenScale(screens()->scale(i));
             GLRenderTarget::setVirtualScreenScale(screens()->scale(i));
 
             const GLenum status = glGetGraphicsResetStatus();
             if (status != GL_NO_ERROR) {
                 handleGraphicsReset(status);
                 return 0;
             }
 
             int mask = 0;
             updateProjectionMatrix();
             paintScreen(&mask, damage.intersected(geo), repaint, &update, &valid, projectionMatrix(), geo);   // call generic implementation
             paintCursor();
 
             GLVertexBuffer::streamingBuffer()->endOfFrame();
 
             m_backend->endRenderingFrameForScreen(i, valid, update);
 
             GLVertexBuffer::streamingBuffer()->framePosted();
         }
     } else {
         m_backend->makeCurrent();
         QRegion repaint = m_backend->prepareRenderingFrame();
 
         const GLenum status = glGetGraphicsResetStatus();
         if (status != GL_NO_ERROR) {
             handleGraphicsReset(status);
             return 0;
         }
         GLVertexBuffer::setVirtualScreenGeometry(screens()->geometry());
         GLRenderTarget::setVirtualScreenGeometry(screens()->geometry());
         GLVertexBuffer::setVirtualScreenScale(1);
         GLRenderTarget::setVirtualScreenScale(1);
 
         int mask = 0;
         updateProjectionMatrix();
         paintScreen(&mask, damage, repaint, &updateRegion, &validRegion, projectionMatrix());   // call generic implementation
 
         if (!GLPlatform::instance()->isGLES()) {
             const QSize &screenSize = screens()->size();
             const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
 
             // copy dirty parts from front to backbuffer
             if (!m_backend->supportsBufferAge() &&
                 options->glPreferBufferSwap() == Options::CopyFrontBuffer &&
                 validRegion != displayRegion) {
                 glReadBuffer(GL_FRONT);
                 m_backend->copyPixels(displayRegion - validRegion);
                 glReadBuffer(GL_BACK);
                 validRegion = displayRegion;
             }
         }
 
         GLVertexBuffer::streamingBuffer()->endOfFrame();
 
         m_backend->endRenderingFrame(validRegion, updateRegion);
 
         GLVertexBuffer::streamingBuffer()->framePosted();
     }
 
     if (m_currentFence) {
         if (!m_syncManager->updateFences()) {
             qCDebug(KWIN_OPENGL) << "Aborting explicit synchronization with the X command stream.";
             qCDebug(KWIN_OPENGL) << "Future frames will be rendered unsynchronized.";
             delete m_syncManager;
             m_syncManager = nullptr;
         }
         m_currentFence = nullptr;
     }
 
     // do cleanup
     clearStackingOrder();
     return m_backend->renderTime();
 }
 
 QMatrix4x4 SceneOpenGL::transformation(int mask, const ScreenPaintData &data) const
 {
     QMatrix4x4 matrix;
 
     if (!(mask & PAINT_SCREEN_TRANSFORMED))
         return matrix;
 
     matrix.translate(data.translation());
     data.scale().applyTo(&matrix);
 
     if (data.rotationAngle() == 0.0)
         return matrix;
 
     // Apply the rotation
     // cannot use data.rotation->applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
     matrix.translate(data.rotationOrigin());
     const QVector3D axis = data.rotationAxis();
     matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
     matrix.translate(-data.rotationOrigin());
 
     return matrix;
 }
 
 void SceneOpenGL::paintBackground(QRegion region)
 {
     PaintClipper pc(region);
     if (!PaintClipper::clip()) {
         glClearColor(0, 0, 0, 1);
         glClear(GL_COLOR_BUFFER_BIT);
         return;
     }
     if (pc.clip() && pc.paintArea().isEmpty())
         return; // no background to paint
     QVector<float> verts;
     for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
         QRect r = iterator.boundingRect();
         verts << r.x() + r.width() << r.y();
         verts << r.x() << r.y();
         verts << r.x() << r.y() + r.height();
         verts << r.x() << r.y() + r.height();
         verts << r.x() + r.width() << r.y() + r.height();
         verts << r.x() + r.width() << r.y();
     }
     doPaintBackground(verts);
 }
 
 void SceneOpenGL::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
 {
     if (m_backend->supportsBufferAge())
         return;
 
     const QSize &screenSize = screens()->size();
     if (options->glPreferBufferSwap() == Options::ExtendDamage) { // only Extend "large" repaints
         const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
         uint damagedPixels = 0;
         const uint fullRepaintLimit = (opaqueFullscreen?0.49f:0.748f)*screenSize.width()*screenSize.height();
         // 16:9 is 75% of 4:3 and 2.55:1 is 49.01% of 5:4
         // (5:4 is the most square format and 2.55:1 is Cinemascope55 - the widest ever shot
         // movie aspect - two times ;-) It's a Fox format, though, so maybe we want to restrict
         // to 2.20:1 - Panavision - which has actually been used for interesting movies ...)
         // would be 57% of 5/4
         for (const QRect &r : region) {
 //                 damagedPixels += r.width() * r.height(); // combined window damage test
             damagedPixels = r.width() * r.height(); // experimental single window damage testing
             if (damagedPixels > fullRepaintLimit) {
                 region = displayRegion;
                 return;
             }
         }
     } else if (options->glPreferBufferSwap() == Options::PaintFullScreen) { // forced full rePaint
         region = QRegion(0, 0, screenSize.width(), screenSize.height());
     }
 }
 
 SceneOpenGLTexture *SceneOpenGL::createTexture()
 {
     return new SceneOpenGLTexture(m_backend);
 }
 
 bool SceneOpenGL::viewportLimitsMatched(const QSize &size) const {
     if (kwinApp()->operationMode() != Application::OperationModeX11) {
         // TODO: On Wayland we can't suspend. Find a solution that works here as well!
         return true;
     }
     GLint limit[2];
     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, limit);
     if (limit[0] < size.width() || limit[1] < size.height()) {
         auto compositor = static_cast<X11Compositor*>(Compositor::self());
         QMetaObject::invokeMethod(compositor, [compositor]() {
                 compositor->suspend(X11Compositor::AllReasonSuspend);
             }, Qt::QueuedConnection);
         return false;
     }
     return true;
 }
 
 void SceneOpenGL::screenGeometryChanged(const QSize &size)
 {
     if (!viewportLimitsMatched(size))
         return;
     Scene::screenGeometryChanged(size);
     glViewport(0,0, size.width(), size.height());
     m_backend->screenGeometryChanged(size);
     GLRenderTarget::setVirtualScreenSize(size);
 }
 
 void SceneOpenGL::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     const QRect r = region.boundingRect();
     glEnable(GL_SCISSOR_TEST);
     glScissor(r.x(), screens()->size().height() - r.y() - r.height(), r.width(), r.height());
     KWin::Scene::paintDesktop(desktop, mask, region, data);
     glDisable(GL_SCISSOR_TEST);
 }
 
 void SceneOpenGL::paintEffectQuickView(EffectQuickView *w)
 {
     GLShader *shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
     const QRect rect = w->geometry();
 
     GLTexture *t = w->bufferAsTexture();
     if (!t) {
         return;
     }
 
     QMatrix4x4 mvp(projectionMatrix());
     mvp.translate(rect.x(), rect.y());
     shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     t->bind();
     t->render(QRegion(infiniteRegion()), w->geometry());
     t->unbind();
     glDisable(GL_BLEND);
 
     ShaderManager::instance()->popShader();
 }
 
 bool SceneOpenGL::makeOpenGLContextCurrent()
 {
     return m_backend->makeCurrent();
 }
 
 void SceneOpenGL::doneOpenGLContextCurrent()
 {
     m_backend->doneCurrent();
 }
 
 Scene::EffectFrame *SceneOpenGL::createEffectFrame(EffectFrameImpl *frame)
 {
     return new SceneOpenGL::EffectFrame(frame, this);
 }
 
 Shadow *SceneOpenGL::createShadow(Toplevel *toplevel)
 {
     return new SceneOpenGLShadow(toplevel);
 }
 
 Decoration::Renderer *SceneOpenGL::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
 {
     return new SceneOpenGLDecorationRenderer(impl);
 }
 
 bool SceneOpenGL::animationsSupported() const
 {
     return !GLPlatform::instance()->isSoftwareEmulation();
 }
 
 QVector<QByteArray> SceneOpenGL::openGLPlatformInterfaceExtensions() const
 {
     return m_backend->extensions().toVector();
 }
 
 //****************************************
 // SceneOpenGL2
 //****************************************
 bool SceneOpenGL2::supported(OpenGLBackend *backend)
 {
     const QByteArray forceEnv = qgetenv("KWIN_COMPOSE");
     if (!forceEnv.isEmpty()) {
         if (qstrcmp(forceEnv, "O2") == 0 || qstrcmp(forceEnv, "O2ES") == 0) {
             qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing enforced by environment variable";
             return true;
         } else {
             // OpenGL 2 disabled by environment variable
             return false;
         }
     }
     if (!backend->isDirectRendering()) {
         return false;
     }
     if (GLPlatform::instance()->recommendedCompositor() < OpenGL2Compositing) {
         qCDebug(KWIN_OPENGL) << "Driver does not recommend OpenGL 2 compositing";
         return false;
     }
     return true;
 }
 
 SceneOpenGL2::SceneOpenGL2(OpenGLBackend *backend, QObject *parent)
     : SceneOpenGL(backend, parent)
     , m_lanczosFilter(nullptr)
 {
     if (!init_ok) {
         // base ctor already failed
         return;
     }
 
     // We only support the OpenGL 2+ shader API, not GL_ARB_shader_objects
     if (!hasGLVersion(2, 0)) {
         qCDebug(KWIN_OPENGL) << "OpenGL 2.0 is not supported";
         init_ok = false;
         return;
     }
 
     const QSize &s = screens()->size();
     GLRenderTarget::setVirtualScreenSize(s);
     GLRenderTarget::setVirtualScreenGeometry(screens()->geometry());
 
     // push one shader on the stack so that one is always bound
     ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
     if (checkGLError("Init")) {
         qCCritical(KWIN_OPENGL) << "OpenGL 2 compositing setup failed";
         init_ok = false;
         return; // error
     }
 
     // It is not legal to not have a vertex array object bound in a core context
     if (!GLPlatform::instance()->isGLES() && hasGLExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
         glGenVertexArrays(1, &vao);
         glBindVertexArray(vao);
     }
 
     if (!ShaderManager::instance()->selfTest()) {
         qCCritical(KWIN_OPENGL) << "ShaderManager self test failed";
         init_ok = false;
         return;
     }
 
     qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing successfully initialized";
     init_ok = true;
 }
 
 SceneOpenGL2::~SceneOpenGL2()
 {
     if (m_lanczosFilter) {
         makeOpenGLContextCurrent();
         delete m_lanczosFilter;
         m_lanczosFilter = nullptr;
     }
 }
 
 QMatrix4x4 SceneOpenGL2::createProjectionMatrix() const
 {
     // Create a perspective projection with a 60° field-of-view,
     // and an aspect ratio of 1.0.
     const float fovY   =   60.0f;
     const float aspect =    1.0f;
     const float zNear  =    0.1f;
     const float zFar   =  100.0f;
 
     const float yMax   =  zNear * std::tan(fovY * M_PI / 360.0f);
     const float yMin   = -yMax;
     const float xMin   =  yMin * aspect;
     const float xMax   =  yMax * aspect;
 
     QMatrix4x4 projection;
     projection.frustum(xMin, xMax, yMin, yMax, zNear, zFar);
 
     // Create a second matrix that transforms screen coordinates
     // to world coordinates.
     const float scaleFactor = 1.1 * std::tan(fovY * M_PI / 360.0f) / yMax;
     const QSize size = screens()->size();
 
     QMatrix4x4 matrix;
     matrix.translate(xMin * scaleFactor, yMax * scaleFactor, -1.1);
     matrix.scale( (xMax - xMin) * scaleFactor / size.width(),
                  -(yMax - yMin) * scaleFactor / size.height(),
                   0.001);
 
     // Combine the matrices
     return projection * matrix;
 }
 
 void SceneOpenGL2::updateProjectionMatrix()
 {
     m_projectionMatrix = createProjectionMatrix();
 }
 
 void SceneOpenGL2::paintSimpleScreen(int mask, QRegion region)
 {
     m_screenProjectionMatrix = m_projectionMatrix;
 
     Scene::paintSimpleScreen(mask, region);
 }
 
 void SceneOpenGL2::paintGenericScreen(int mask, ScreenPaintData data)
 {
     const QMatrix4x4 screenMatrix = transformation(mask, data);
 
     m_screenProjectionMatrix = m_projectionMatrix * screenMatrix;
 
     Scene::paintGenericScreen(mask, data);
 }
 
 void SceneOpenGL2::doPaintBackground(const QVector< float >& vertices)
 {
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     vbo->setUseColor(true);
     vbo->setData(vertices.count() / 2, 2, vertices.data(), nullptr);
 
     ShaderBinder binder(ShaderTrait::UniformColor);
     binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, m_projectionMatrix);
 
     vbo->render(GL_TRIANGLES);
 }
 
 Scene::Window *SceneOpenGL2::createWindow(Toplevel *t)
 {
     SceneOpenGL2Window *w = new SceneOpenGL2Window(t);
     w->setScene(this);
     return w;
 }
 
 void SceneOpenGL2::finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
         return;
     }
     performPaintWindow(w, mask, region, data);
 }
 
 void SceneOpenGL2::performPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (mask & PAINT_WINDOW_LANCZOS) {
         if (!m_lanczosFilter) {
             m_lanczosFilter = new LanczosFilter(this);
             // reset the lanczos filter when the screen gets resized
             // it will get created next paint
             connect(screens(), &Screens::changed, this, [this]() {
                 makeOpenGLContextCurrent();
                 delete m_lanczosFilter;
                 m_lanczosFilter = nullptr;
             });
         }
         m_lanczosFilter->performPaint(w, mask, region, data);
     } else
         w->sceneWindow()->performPaint(mask, region, data);
 }
 
 //****************************************
 // SceneOpenGL::Window
 //****************************************
 
 SceneOpenGL::Window::Window(Toplevel* c)
     : Scene::Window(c)
     , m_scene(nullptr)
 {
 }
 
 SceneOpenGL::Window::~Window()
 {
 }
 
 static SceneOpenGLTexture *s_frameTexture = nullptr;
 // Bind the window pixmap to an OpenGL texture.
 bool SceneOpenGL::Window::bindTexture()
 {
     s_frameTexture = nullptr;
     OpenGLWindowPixmap *pixmap = windowPixmap<OpenGLWindowPixmap>();
     if (!pixmap) {
         return false;
     }
     s_frameTexture = pixmap->texture();
     if (pixmap->isDiscarded()) {
         return !pixmap->texture()->isNull();
     }
 
     if (!window()->damage().isEmpty())
         m_scene->insertWait();
 
     return pixmap->bind();
 }
 
 QMatrix4x4 SceneOpenGL::Window::transformation(int mask, const WindowPaintData &data) const
 {
     QMatrix4x4 matrix;
     matrix.translate(x(), y());
 
     if (!(mask & PAINT_WINDOW_TRANSFORMED))
         return matrix;
 
     matrix.translate(data.translation());
     data.scale().applyTo(&matrix);
 
     if (data.rotationAngle() == 0.0)
         return matrix;
 
     // Apply the rotation
     // cannot use data.rotation.applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
     matrix.translate(data.rotationOrigin());
     const QVector3D axis = data.rotationAxis();
     matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
     matrix.translate(-data.rotationOrigin());
 
     return matrix;
 }
 
 bool SceneOpenGL::Window::beginRenderWindow(int mask, const QRegion &region, WindowPaintData &data)
 {
     if (region.isEmpty())
         return false;
 
     m_hardwareClipping = region != infiniteRegion() && (mask & PAINT_WINDOW_TRANSFORMED) && !(mask & PAINT_SCREEN_TRANSFORMED);
     if (region != infiniteRegion() && !m_hardwareClipping) {
         WindowQuadList quads;
         quads.reserve(data.quads.count());
 
         const QRegion filterRegion = region.translated(-x(), -y());
         // split all quads in bounding rect with the actual rects in the region
         foreach (const WindowQuad &quad, data.quads) {
             for (const QRect &r : filterRegion) {
                 const QRectF rf(r);
                 const QRectF quadRect(QPointF(quad.left(), quad.top()), QPointF(quad.right(), quad.bottom()));
                 const QRectF &intersected = rf.intersected(quadRect);
                 if (intersected.isValid()) {
                     if (quadRect == intersected) {
                         // case 1: completely contains, include and do not check other rects
                         quads << quad;
                         break;
                     }
                     // case 2: intersection
                     quads << quad.makeSubQuad(intersected.left(), intersected.top(), intersected.right(), intersected.bottom());
                 }
             }
         }
         data.quads = quads;
     }
 
     if (data.quads.isEmpty())
         return false;
 
     if (!bindTexture() || !s_frameTexture) {
         return false;
     }
 
     if (m_hardwareClipping) {
         glEnable(GL_SCISSOR_TEST);
     }
 
     // Update the texture filter
     if (waylandServer()) {
         filter = ImageFilterGood;
         s_frameTexture->setFilter(GL_LINEAR);
     } else {
         if (options->glSmoothScale() != 0 &&
             (mask & (PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_TRANSFORMED)))
             filter = ImageFilterGood;
         else
             filter = ImageFilterFast;
 
         s_frameTexture->setFilter(filter == ImageFilterGood ? GL_LINEAR : GL_NEAREST);
     }
 
     const GLVertexAttrib attribs[] = {
         { VA_Position, 2, GL_FLOAT, offsetof(GLVertex2D, position) },
         { VA_TexCoord, 2, GL_FLOAT, offsetof(GLVertex2D, texcoord) },
     };
 
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     vbo->setAttribLayout(attribs, 2, sizeof(GLVertex2D));
 
     return true;
 }
 
 void SceneOpenGL::Window::endRenderWindow()
 {
     if (m_hardwareClipping) {
         glDisable(GL_SCISSOR_TEST);
     }
 }
 
 GLTexture *SceneOpenGL::Window::getDecorationTexture() const
 {
     if (AbstractClient *client = dynamic_cast<AbstractClient *>(toplevel)) {
         if (client->noBorder()) {
             return nullptr;
         }
 
         if (!client->isDecorated()) {
             return nullptr;
         }
         if (SceneOpenGLDecorationRenderer *renderer = static_cast<SceneOpenGLDecorationRenderer*>(client->decoratedClient()->renderer())) {
             renderer->render();
             return renderer->texture();
         }
     } else if (toplevel->isDeleted()) {
         Deleted *deleted = static_cast<Deleted *>(toplevel);
         if (!deleted->wasClient() || deleted->noBorder()) {
             return nullptr;
         }
         if (const SceneOpenGLDecorationRenderer *renderer = static_cast<const SceneOpenGLDecorationRenderer*>(deleted->decorationRenderer())) {
             return renderer->texture();
         }
     }
     return nullptr;
 }
 
 WindowPixmap* SceneOpenGL::Window::createWindowPixmap()
 {
     return new OpenGLWindowPixmap(this, m_scene);
 }
 
 //***************************************
 // SceneOpenGL2Window
 //***************************************
 SceneOpenGL2Window::SceneOpenGL2Window(Toplevel *c)
     : SceneOpenGL::Window(c)
     , m_blendingEnabled(false)
 {
 }
 
 SceneOpenGL2Window::~SceneOpenGL2Window()
 {
 }
 
 QVector4D SceneOpenGL2Window::modulate(float opacity, float brightness) const
 {
     const float a = opacity;
     const float rgb = opacity * brightness;
 
     return QVector4D(rgb, rgb, rgb, a);
 }
 
 void SceneOpenGL2Window::setBlendEnabled(bool enabled)
 {
     if (enabled && !m_blendingEnabled)
         glEnable(GL_BLEND);
     else if (!enabled && m_blendingEnabled)
         glDisable(GL_BLEND);
 
     m_blendingEnabled = enabled;
 }
 
 void SceneOpenGL2Window::setupLeafNodes(LeafNode *nodes, const WindowQuadList *quads, const WindowPaintData &data)
 {
     if (!quads[ShadowLeaf].isEmpty()) {
         nodes[ShadowLeaf].texture = static_cast<SceneOpenGLShadow *>(m_shadow)->shadowTexture();
         nodes[ShadowLeaf].opacity = data.opacity();
         nodes[ShadowLeaf].hasAlpha = true;
         nodes[ShadowLeaf].coordinateType = NormalizedCoordinates;
     }
 
     if (!quads[DecorationLeaf].isEmpty()) {
         nodes[DecorationLeaf].texture = getDecorationTexture();
         nodes[DecorationLeaf].opacity = data.opacity();
         nodes[DecorationLeaf].hasAlpha = true;
         nodes[DecorationLeaf].coordinateType = UnnormalizedCoordinates;
     }
 
     nodes[ContentLeaf].texture = s_frameTexture;
     nodes[ContentLeaf].hasAlpha = !isOpaque();
     // TODO: ARGB crsoofading is atm. a hack, playing on opacities for two dumb SrcOver operations
     // Should be a shader
     if (data.crossFadeProgress() != 1.0 && (data.opacity() < 0.95 || toplevel->hasAlpha())) {
         const float opacity = 1.0 - data.crossFadeProgress();
         nodes[ContentLeaf].opacity = data.opacity() * (1 - pow(opacity, 1.0f + 2.0f * data.opacity()));
     } else {
         nodes[ContentLeaf].opacity = data.opacity();
     }
     nodes[ContentLeaf].coordinateType = UnnormalizedCoordinates;
 
     if (data.crossFadeProgress() != 1.0) {
         OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
         nodes[PreviousContentLeaf].texture = previous ? previous->texture() : nullptr;
         nodes[PreviousContentLeaf].hasAlpha = !isOpaque();
         nodes[PreviousContentLeaf].opacity = data.opacity() * (1.0 - data.crossFadeProgress());
         nodes[PreviousContentLeaf].coordinateType = NormalizedCoordinates;
     }
 }
 
 QMatrix4x4 SceneOpenGL2Window::modelViewProjectionMatrix(int mask, const WindowPaintData &data) const
 {
     SceneOpenGL2 *scene = static_cast<SceneOpenGL2 *>(m_scene);
 
     const QMatrix4x4 pMatrix = data.projectionMatrix();
     const QMatrix4x4 mvMatrix = data.modelViewMatrix();
 
     // An effect may want to override the default projection matrix in some cases,
     // such as when it is rendering a window on a render target that doesn't have
     // the same dimensions as the default framebuffer.
     //
     // Note that the screen transformation is not applied here.
     if (!pMatrix.isIdentity())
         return pMatrix * mvMatrix;
 
     // If an effect has specified a model-view matrix, we multiply that matrix
     // with the default projection matrix.  If the effect hasn't specified a
     // model-view matrix, mvMatrix will be the identity matrix.
     if (mask & Scene::PAINT_SCREEN_TRANSFORMED)
         return scene->screenProjectionMatrix() * mvMatrix;
 
     return scene->projectionMatrix() * mvMatrix;
 }
 
 void SceneOpenGL2Window::renderSubSurface(GLShader *shader, const QMatrix4x4 &mvp, const QMatrix4x4 &windowMatrix, OpenGLWindowPixmap *pixmap, const QRegion &region, bool hardwareClipping)
 {
     QMatrix4x4 newWindowMatrix = windowMatrix;
     newWindowMatrix.translate(pixmap->subSurface()->position().x(), pixmap->subSurface()->position().y());
 
     qreal scale = 1.0;
     if (pixmap->surface()) {
         scale = pixmap->surface()->scale();
     }
 
     if (!pixmap->texture()->isNull()) {
         setBlendEnabled(pixmap->buffer() && pixmap->buffer()->hasAlphaChannel());
         // render this texture
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp * newWindowMatrix);
         auto texture = pixmap->texture();
         texture->bind();
         texture->render(region, QRect(0, 0, texture->width() / scale, texture->height() / scale), hardwareClipping);
         texture->unbind();
     }
 
     const auto &children = pixmap->children();
     for (auto pixmap : children) {
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         renderSubSurface(shader, mvp, newWindowMatrix, static_cast<OpenGLWindowPixmap*>(pixmap), region, hardwareClipping);
     }
 }
 
 void SceneOpenGL2Window::performPaint(int mask, QRegion region, WindowPaintData data)
 {
     if (!beginRenderWindow(mask, region, data))
         return;
 
     QMatrix4x4 windowMatrix = transformation(mask, data);
     const QMatrix4x4 modelViewProjection = modelViewProjectionMatrix(mask, data);
     const QMatrix4x4 mvpMatrix = modelViewProjection * windowMatrix;
 
     GLShader *shader = data.shader;
     if (!shader) {
         ShaderTraits traits = ShaderTrait::MapTexture;
 
         if (data.opacity() != 1.0 || data.brightness() != 1.0 || data.crossFadeProgress() != 1.0)
             traits |= ShaderTrait::Modulate;
 
         if (data.saturation() != 1.0)
             traits |= ShaderTrait::AdjustSaturation;
 
         shader = ShaderManager::instance()->pushShader(traits);
     }
     shader->setUniform(GLShader::ModelViewProjectionMatrix, mvpMatrix);
 
     shader->setUniform(GLShader::Saturation, data.saturation());
 
     GLenum filter;
     if (waylandServer()) {
         filter = GL_LINEAR;
     } else {
         const bool isTransformed = mask & (Effect::PAINT_WINDOW_TRANSFORMED |
                                            Effect::PAINT_SCREEN_TRANSFORMED);
         if (isTransformed && options->glSmoothScale() != 0) {
             filter = GL_LINEAR;
         } else {
             filter = GL_NEAREST;
         }
     }
 
     WindowQuadList quads[LeafCount];
 
     // Split the quads into separate lists for each type
     foreach (const WindowQuad &quad, data.quads) {
         switch (quad.type()) {
         case WindowQuadDecoration:
             quads[DecorationLeaf].append(quad);
             continue;
 
         case WindowQuadContents:
             quads[ContentLeaf].append(quad);
             continue;
 
         case WindowQuadShadow:
             quads[ShadowLeaf].append(quad);
             continue;
 
         default:
             continue;
         }
     }
 
     if (data.crossFadeProgress() != 1.0) {
         OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
         if (previous) {
             const QRect &oldGeometry = previous->contentsRect();
             for (const WindowQuad &quad : quads[ContentLeaf]) {
                 // we need to create new window quads with normalize texture coordinates
                 // normal quads divide the x/y position by width/height. This would not work as the texture
                 // is larger than the visible content in case of a decorated Client resulting in garbage being shown.
                 // So we calculate the normalized texture coordinate in the Client's new content space and map it to
                 // the previous Client's content space.
                 WindowQuad newQuad(WindowQuadContents);
                 for (int i = 0; i < 4; ++i) {
                     const qreal xFactor = qreal(quad[i].textureX() - toplevel->clientPos().x())/qreal(toplevel->clientSize().width());
                     const qreal yFactor = qreal(quad[i].textureY() - toplevel->clientPos().y())/qreal(toplevel->clientSize().height());
                     WindowVertex vertex(quad[i].x(), quad[i].y(),
                                         (xFactor * oldGeometry.width() + oldGeometry.x())/qreal(previous->size().width()),
                                         (yFactor * oldGeometry.height() + oldGeometry.y())/qreal(previous->size().height()));
                     newQuad[i] = vertex;
                 }
                 quads[PreviousContentLeaf].append(newQuad);
             }
         }
     }
 
     const bool indexedQuads = GLVertexBuffer::supportsIndexedQuads();
     const GLenum primitiveType = indexedQuads ? GL_QUADS : GL_TRIANGLES;
     const int verticesPerQuad = indexedQuads ? 4 : 6;
 
     const size_t size = verticesPerQuad *
         (quads[0].count() + quads[1].count() + quads[2].count() + quads[3].count()) * sizeof(GLVertex2D);
 
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     GLVertex2D *map = (GLVertex2D *) vbo->map(size);
 
     LeafNode nodes[LeafCount];
     setupLeafNodes(nodes, quads, data);
 
     for (int i = 0, v = 0; i < LeafCount; i++) {
         if (quads[i].isEmpty() || !nodes[i].texture)
             continue;
 
         nodes[i].firstVertex = v;
         nodes[i].vertexCount = quads[i].count() * verticesPerQuad;
 
         const QMatrix4x4 matrix = nodes[i].texture->matrix(nodes[i].coordinateType);
 
         quads[i].makeInterleavedArrays(primitiveType, &map[v], matrix);
         v += quads[i].count() * verticesPerQuad;
     }
 
     vbo->unmap();
     vbo->bindArrays();
 
     // Make sure the blend function is set up correctly in case we will be doing blending
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
     float opacity = -1.0;
 
     for (int i = 0; i < LeafCount; i++) {
         if (nodes[i].vertexCount == 0)
             continue;
 
         setBlendEnabled(nodes[i].hasAlpha || nodes[i].opacity < 1.0);
 
         if (opacity != nodes[i].opacity) {
             shader->setUniform(GLShader::ModulationConstant,
                                modulate(nodes[i].opacity, data.brightness()));
             opacity = nodes[i].opacity;
         }
 
         nodes[i].texture->setFilter(filter);
         nodes[i].texture->setWrapMode(GL_CLAMP_TO_EDGE);
         nodes[i].texture->bind();
 
         vbo->draw(region, primitiveType, nodes[i].firstVertex, nodes[i].vertexCount, m_hardwareClipping);
     }
 
     vbo->unbindArrays();
 
     // render sub-surfaces
     auto wp = windowPixmap<OpenGLWindowPixmap>();
     const auto &children = wp ? wp->children() : QVector<WindowPixmap*>();
     windowMatrix.translate(toplevel->clientPos().x(), toplevel->clientPos().y());
     for (auto pixmap : children) {
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         renderSubSurface(shader, modelViewProjection, windowMatrix, static_cast<OpenGLWindowPixmap*>(pixmap), region, m_hardwareClipping);
     }
 
     setBlendEnabled(false);
 
     if (!data.shader)
         ShaderManager::instance()->popShader();
 
     endRenderWindow();
 }
 
 
 //****************************************
 // OpenGLWindowPixmap
 //****************************************
 
 OpenGLWindowPixmap::OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL* scene)
     : WindowPixmap(window)
     , m_texture(scene->createTexture())
     , m_scene(scene)
 {
 }
 
 OpenGLWindowPixmap::OpenGLWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene)
     : WindowPixmap(subSurface, parent)
     , m_texture(scene->createTexture())
     , m_scene(scene)
 {
 }
 
 OpenGLWindowPixmap::~OpenGLWindowPixmap()
 {
 }
 
 static bool needsPixmapUpdate(const OpenGLWindowPixmap *pixmap)
 {
     // That's a regular Wayland client.
     if (pixmap->surface()) {
         return !pixmap->surface()->trackedDamage().isEmpty();
     }
 
     // That's an internal client with a raster buffer attached.
     if (!pixmap->internalImage().isNull()) {
         return !pixmap->toplevel()->damage().isEmpty();
     }
 
     // That's an internal client with an opengl framebuffer object attached.
     if (!pixmap->fbo().isNull()) {
         return !pixmap->toplevel()->damage().isEmpty();
     }
 
     // That's an X11 client.
     return false;
 }
 
 bool OpenGLWindowPixmap::bind()
 {
     if (!m_texture->isNull()) {
         // always call updateBuffer to get the sub-surface tree updated
         if (subSurface().isNull() && !toplevel()->damage().isEmpty()) {
             updateBuffer();
         }
         if (needsPixmapUpdate(this)) {
             m_texture->updateFromPixmap(this);
             // mipmaps need to be updated
             m_texture->setDirty();
         }
         if (subSurface().isNull()) {
             toplevel()->resetDamage();
         }
         // also bind all children
         for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
             static_cast<OpenGLWindowPixmap*>(*it)->bind();
         }
         return true;
     }
     // also bind all children, needs to be done before checking isValid
     // as there might be valid children to render, see https://bugreports.qt.io/browse/QTBUG-52192
     if (subSurface().isNull()) {
         updateBuffer();
     }
     for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
         static_cast<OpenGLWindowPixmap*>(*it)->bind();
     }
     if (!isValid()) {
         return false;
     }
 
     bool success = m_texture->load(this);
 
     if (success) {
         if (subSurface().isNull()) {
             toplevel()->resetDamage();
         }
     } else
         qCDebug(KWIN_OPENGL) << "Failed to bind window";
     return success;
 }
 
 WindowPixmap *OpenGLWindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
 {
     return new OpenGLWindowPixmap(subSurface, this, m_scene);
 }
 
 bool OpenGLWindowPixmap::isValid() const
 {
     if (!m_texture->isNull()) {
         return true;
     }
     return WindowPixmap::isValid();
 }
 
 //****************************************
 // SceneOpenGL::EffectFrame
 //****************************************
 
 GLTexture* SceneOpenGL::EffectFrame::m_unstyledTexture = nullptr;
 QPixmap* SceneOpenGL::EffectFrame::m_unstyledPixmap = nullptr;
 
 SceneOpenGL::EffectFrame::EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene)
     : Scene::EffectFrame(frame)
     , m_texture(nullptr)
     , m_textTexture(nullptr)
     , m_oldTextTexture(nullptr)
     , m_textPixmap(nullptr)
     , m_iconTexture(nullptr)
     , m_oldIconTexture(nullptr)
     , m_selectionTexture(nullptr)
     , m_unstyledVBO(nullptr)
     , m_scene(scene)
 {
     if (m_effectFrame->style() == EffectFrameUnstyled && !m_unstyledTexture) {
         updateUnstyledTexture();
     }
 }
 
 SceneOpenGL::EffectFrame::~EffectFrame()
 {
     delete m_texture;
     delete m_textTexture;
     delete m_textPixmap;
     delete m_oldTextTexture;
     delete m_iconTexture;
     delete m_oldIconTexture;
     delete m_selectionTexture;
     delete m_unstyledVBO;
 }
 
 void SceneOpenGL::EffectFrame::free()
 {
     glFlush();
     delete m_texture;
     m_texture = nullptr;
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
     delete m_iconTexture;
     m_iconTexture = nullptr;
     delete m_selectionTexture;
     m_selectionTexture = nullptr;
     delete m_unstyledVBO;
     m_unstyledVBO = nullptr;
     delete m_oldIconTexture;
     m_oldIconTexture = nullptr;
     delete m_oldTextTexture;
     m_oldTextTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeIconFrame()
 {
     delete m_iconTexture;
     m_iconTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeTextFrame()
 {
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeSelection()
 {
     delete m_selectionTexture;
     m_selectionTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::crossFadeIcon()
 {
     delete m_oldIconTexture;
     m_oldIconTexture = m_iconTexture;
     m_iconTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::crossFadeText()
 {
     delete m_oldTextTexture;
     m_oldTextTexture = m_textTexture;
     m_textTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::render(QRegion region, double opacity, double frameOpacity)
 {
     if (m_effectFrame->geometry().isEmpty())
         return; // Nothing to display
 
     region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
 
     GLShader* shader = m_effectFrame->shader();
     if (!shader) {
         shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture | ShaderTrait::Modulate);
     } else if (shader) {
         ShaderManager::instance()->pushShader(shader);
     }
 
     if (shader) {
         shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
         shader->setUniform(GLShader::Saturation, 1.0f);
     }
     const QMatrix4x4 projection = m_scene->projectionMatrix();
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     // Render the actual frame
     if (m_effectFrame->style() == EffectFrameUnstyled) {
         if (!m_unstyledVBO) {
             m_unstyledVBO = new GLVertexBuffer(GLVertexBuffer::Static);
             QRect area = m_effectFrame->geometry();
             area.moveTo(0, 0);
             area.adjust(-5, -5, 5, 5);
 
             const int roundness = 5;
             QVector<float> verts, texCoords;
             verts.reserve(84);
             texCoords.reserve(84);
 
             // top left
             verts << area.left() << area.top();
             texCoords << 0.0f << 0.0f;
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             // top
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             // top right
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() << area.top();
             texCoords << 1.0f << 0.0f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() << area.top();
             texCoords << 1.0f << 0.0f;
             // bottom left
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() << area.bottom();
             texCoords << 0.0f << 1.0f;
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.left() << area.bottom();
             texCoords << 0.0f << 1.0f;
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             // bottom
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             // bottom right
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() << area.bottom();
             texCoords << 1.0f << 1.0f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             // center
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
 
             m_unstyledVBO->setData(verts.count() / 2, 2, verts.data(), texCoords.data());
         }
 
         if (shader) {
             const float a = opacity * frameOpacity;
             shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
         }
 
         m_unstyledTexture->bind();
         const QPoint pt = m_effectFrame->geometry().topLeft();
 
         QMatrix4x4 mvp(projection);
         mvp.translate(pt.x(), pt.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         m_unstyledVBO->render(region, GL_TRIANGLES);
         m_unstyledTexture->unbind();
     } else if (m_effectFrame->style() == EffectFrameStyled) {
         if (!m_texture)   // Lazy creation
             updateTexture();
 
         if (shader) {
             const float a = opacity * frameOpacity;
             shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
         }
         m_texture->bind();
         qreal left, top, right, bottom;
         m_effectFrame->frame().getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         const QRect rect = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
 
         QMatrix4x4 mvp(projection);
         mvp.translate(rect.x(), rect.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         m_texture->render(region, rect);
         m_texture->unbind();
 
     }
     if (!m_effectFrame->selection().isNull()) {
         if (!m_selectionTexture) { // Lazy creation
             QPixmap pixmap = m_effectFrame->selectionFrame().framePixmap();
             if (!pixmap.isNull())
                 m_selectionTexture = new GLTexture(pixmap);
         }
         if (m_selectionTexture) {
             if (shader) {
                 const float a = opacity * frameOpacity;
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
             QMatrix4x4 mvp(projection);
             mvp.translate(m_effectFrame->selection().x(), m_effectFrame->selection().y());
             shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
             glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
             m_selectionTexture->bind();
             m_selectionTexture->render(region, m_effectFrame->selection());
             m_selectionTexture->unbind();
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         }
     }
 
     // Render icon
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
         QPoint topLeft(m_effectFrame->geometry().x(),
                        m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
 
         QMatrix4x4 mvp(projection);
         mvp.translate(topLeft.x(), topLeft.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         if (m_effectFrame->isCrossFade() && m_oldIconTexture) {
             if (shader) {
                 const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
 
             m_oldIconTexture->bind();
             m_oldIconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
             m_oldIconTexture->unbind();
             if (shader) {
                 const float a = opacity * m_effectFrame->crossFadeProgress();
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
         } else {
             if (shader) {
                 const QVector4D constant(opacity, opacity, opacity, opacity);
                 shader->setUniform(GLShader::ModulationConstant, constant);
             }
         }
 
         if (!m_iconTexture) { // lazy creation
             m_iconTexture = new GLTexture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()));
         }
         m_iconTexture->bind();
         m_iconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
         m_iconTexture->unbind();
     }
 
     // Render text
     if (!m_effectFrame->text().isEmpty()) {
         QMatrix4x4 mvp(projection);
         mvp.translate(m_effectFrame->geometry().x(), m_effectFrame->geometry().y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
         if (m_effectFrame->isCrossFade() && m_oldTextTexture) {
             if (shader) {
                 const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
 
             m_oldTextTexture->bind();
             m_oldTextTexture->render(region, m_effectFrame->geometry());
             m_oldTextTexture->unbind();
             if (shader) {
                 const float a = opacity * m_effectFrame->crossFadeProgress();
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
         } else {
             if (shader) {
                 const QVector4D constant(opacity, opacity, opacity, opacity);
                 shader->setUniform(GLShader::ModulationConstant, constant);
             }
         }
         if (!m_textTexture)   // Lazy creation
             updateTextTexture();
 
         if (m_textTexture) {
             m_textTexture->bind();
             m_textTexture->render(region, m_effectFrame->geometry());
             m_textTexture->unbind();
         }
     }
 
     if (shader) {
         ShaderManager::instance()->popShader();
     }
     glDisable(GL_BLEND);
 }
 
 void SceneOpenGL::EffectFrame::updateTexture()
 {
     delete m_texture;
     m_texture = nullptr;
     if (m_effectFrame->style() == EffectFrameStyled) {
         QPixmap pixmap = m_effectFrame->frame().framePixmap();
         m_texture = new GLTexture(pixmap);
     }
 }
 
 void SceneOpenGL::EffectFrame::updateTextTexture()
 {
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
 
     if (m_effectFrame->text().isEmpty())
         return;
 
     // Determine position on texture to paint text
     QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty())
         rect.setLeft(m_effectFrame->iconSize().width());
 
     // If static size elide text as required
     QString text = m_effectFrame->text();
     if (m_effectFrame->isStatic()) {
         QFontMetrics metrics(m_effectFrame->font());
         text = metrics.elidedText(text, Qt::ElideRight, rect.width());
     }
 
     m_textPixmap = new QPixmap(m_effectFrame->geometry().size());
     m_textPixmap->fill(Qt::transparent);
     QPainter p(m_textPixmap);
     p.setFont(m_effectFrame->font());
     if (m_effectFrame->style() == EffectFrameStyled)
         p.setPen(m_effectFrame->styledTextColor());
     else // TODO: What about no frame? Custom color setting required
         p.setPen(Qt::white);
     p.drawText(rect, m_effectFrame->alignment(), text);
     p.end();
     m_textTexture = new GLTexture(*m_textPixmap);
 }
 
 void SceneOpenGL::EffectFrame::updateUnstyledTexture()
 {
     delete m_unstyledTexture;
     m_unstyledTexture = nullptr;
     delete m_unstyledPixmap;
     m_unstyledPixmap = nullptr;
     // Based off circle() from kwinxrenderutils.cpp
 #define CS 8
     m_unstyledPixmap = new QPixmap(2 * CS, 2 * CS);
     m_unstyledPixmap->fill(Qt::transparent);
     QPainter p(m_unstyledPixmap);
     p.setRenderHint(QPainter::Antialiasing);
     p.setPen(Qt::NoPen);
     p.setBrush(Qt::black);
     p.drawEllipse(m_unstyledPixmap->rect());
     p.end();
 #undef CS
     m_unstyledTexture = new GLTexture(*m_unstyledPixmap);
 }
 
 void SceneOpenGL::EffectFrame::cleanup()
 {
     delete m_unstyledTexture;
     m_unstyledTexture = nullptr;
     delete m_unstyledPixmap;
     m_unstyledPixmap = nullptr;
 }
 
 //****************************************
 // SceneOpenGL::Shadow
 //****************************************
 class DecorationShadowTextureCache
 {
 public:
     ~DecorationShadowTextureCache();
     DecorationShadowTextureCache(const DecorationShadowTextureCache&) = delete;
     static DecorationShadowTextureCache &instance();
 
     void unregister(SceneOpenGLShadow *shadow);
     QSharedPointer<GLTexture> getTexture(SceneOpenGLShadow *shadow);
 
 private:
     DecorationShadowTextureCache() = default;
     struct Data {
         QSharedPointer<GLTexture> texture;
         QVector<SceneOpenGLShadow*> shadows;
     };
     QHash<KDecoration2::DecorationShadow*, Data> m_cache;
 };
 
 DecorationShadowTextureCache &DecorationShadowTextureCache::instance()
 {
     static DecorationShadowTextureCache s_instance;
     return s_instance;
 }
 
 DecorationShadowTextureCache::~DecorationShadowTextureCache()
 {
     Q_ASSERT(m_cache.isEmpty());
 }
 
 void DecorationShadowTextureCache::unregister(SceneOpenGLShadow *shadow)
 {
     auto it = m_cache.begin();
     while (it != m_cache.end()) {
         auto &d = it.value();
         // check whether the Vector of Shadows contains our shadow and remove all of them
         auto glIt = d.shadows.begin();
         while (glIt != d.shadows.end()) {
             if (*glIt == shadow) {
                 glIt = d.shadows.erase(glIt);
             } else {
                 glIt++;
             }
         }
         // if there are no shadows any more we can erase the cache entry
         if (d.shadows.isEmpty()) {
             it = m_cache.erase(it);
         } else {
             it++;
         }
     }
 }
 
 QSharedPointer<GLTexture> DecorationShadowTextureCache::getTexture(SceneOpenGLShadow *shadow)
 {
     Q_ASSERT(shadow->hasDecorationShadow());
     unregister(shadow);
     const auto &decoShadow = shadow->decorationShadow();
     Q_ASSERT(!decoShadow.isNull());
     auto it = m_cache.find(decoShadow.data());
     if (it != m_cache.end()) {
         Q_ASSERT(!it.value().shadows.contains(shadow));
         it.value().shadows << shadow;
         return it.value().texture;
     }
     Data d;
     d.shadows << shadow;
     d.texture = QSharedPointer<GLTexture>::create(shadow->decorationShadowImage());
     m_cache.insert(decoShadow.data(), d);
     return d.texture;
 }
 
 SceneOpenGLShadow::SceneOpenGLShadow(Toplevel *toplevel)
     : Shadow(toplevel)
 {
 }
 
 SceneOpenGLShadow::~SceneOpenGLShadow()
 {
     Scene *scene = Compositor::self()->scene();
     if (scene) {
         scene->makeOpenGLContextCurrent();
         DecorationShadowTextureCache::instance().unregister(this);
         m_texture.reset();
     }
 }
 
 static inline void distributeHorizontally(QRectF &leftRect, QRectF &rightRect)
 {
     if (leftRect.right() > rightRect.left()) {
         const qreal boundedRight = qMin(leftRect.right(), rightRect.right());
         const qreal boundedLeft = qMax(leftRect.left(), rightRect.left());
         const qreal halfOverlap = (boundedRight - boundedLeft) / 2.0;
         leftRect.setRight(boundedRight - halfOverlap);
         rightRect.setLeft(boundedLeft + halfOverlap);
     }
 }
 
 static inline void distributeVertically(QRectF &topRect, QRectF &bottomRect)
 {
     if (topRect.bottom() > bottomRect.top()) {
         const qreal boundedBottom = qMin(topRect.bottom(), bottomRect.bottom());
         const qreal boundedTop = qMax(topRect.top(), bottomRect.top());
         const qreal halfOverlap = (boundedBottom - boundedTop) / 2.0;
         topRect.setBottom(boundedBottom - halfOverlap);
         bottomRect.setTop(boundedTop + halfOverlap);
     }
 }
 
 void SceneOpenGLShadow::buildQuads()
 {
     // Do not draw shadows if window width or window height is less than
     // 5 px. 5 is an arbitrary choice.
     if (topLevel()->width() < 5 || topLevel()->height() < 5) {
         m_shadowQuads.clear();
         setShadowRegion(QRegion());
         return;
     }
 
     const QSizeF top(elementSize(ShadowElementTop));
     const QSizeF topRight(elementSize(ShadowElementTopRight));
     const QSizeF right(elementSize(ShadowElementRight));
     const QSizeF bottomRight(elementSize(ShadowElementBottomRight));
     const QSizeF bottom(elementSize(ShadowElementBottom));
     const QSizeF bottomLeft(elementSize(ShadowElementBottomLeft));
     const QSizeF left(elementSize(ShadowElementLeft));
     const QSizeF topLeft(elementSize(ShadowElementTopLeft));
 
     const QMarginsF shadowMargins(
         std::max({topLeft.width(), left.width(), bottomLeft.width()}),
         std::max({topLeft.height(), top.height(), topRight.height()}),
         std::max({topRight.width(), right.width(), bottomRight.width()}),
         std::max({bottomRight.height(), bottom.height(), bottomLeft.height()}));
 
     const QRectF outerRect(QPointF(-leftOffset(), -topOffset()),
                            QPointF(topLevel()->width() + rightOffset(),
                                    topLevel()->height() + bottomOffset()));
 
     const int width = shadowMargins.left() + std::max(top.width(), bottom.width()) + shadowMargins.right();
     const int height = shadowMargins.top() + std::max(left.height(), right.height()) + shadowMargins.bottom();
 
     QRectF topLeftRect;
     if (!topLeft.isEmpty()) {
         topLeftRect = QRectF(outerRect.topLeft(), topLeft);
     } else {
         topLeftRect = QRectF(
             outerRect.left() + shadowMargins.left(),
             outerRect.top() + shadowMargins.top(),
             0, 0);
     }
 
     QRectF topRightRect;
     if (!topRight.isEmpty()) {
         topRightRect = QRectF(
             outerRect.right() - topRight.width(), outerRect.top(),
             topRight.width(), topRight.height());
     } else {
         topRightRect = QRectF(
             outerRect.right() - shadowMargins.right(),
             outerRect.top() + shadowMargins.top(),
             0, 0);
     }
 
     QRectF bottomRightRect;
     if (!bottomRight.isEmpty()) {
         bottomRightRect = QRectF(
             outerRect.right() - bottomRight.width(),
             outerRect.bottom() - bottomRight.height(),
             bottomRight.width(), bottomRight.height());
     } else {
         bottomRightRect = QRectF(
             outerRect.right() - shadowMargins.right(),
             outerRect.bottom() - shadowMargins.bottom(),
             0, 0);
     }
 
     QRectF bottomLeftRect;
     if (!bottomLeft.isEmpty()) {
         bottomLeftRect = QRectF(
             outerRect.left(), outerRect.bottom() - bottomLeft.height(),
             bottomLeft.width(), bottomLeft.height());
     } else {
         bottomLeftRect = QRectF(
             outerRect.left() + shadowMargins.left(),
             outerRect.bottom() - shadowMargins.bottom(),
             0, 0);
     }
 
     // Re-distribute the corner tiles so no one of them is overlapping with others.
     // By doing this, we assume that shadow's corner tiles are symmetric
     // and it is OK to not draw top/right/bottom/left tile between corners.
     // For example, let's say top-left and top-right tiles are overlapping.
     // In that case, the right side of the top-left tile will be shifted to left,
     // the left side of the top-right tile will shifted to right, and the top
     // tile won't be rendered.
     distributeHorizontally(topLeftRect, topRightRect);
     distributeHorizontally(bottomLeftRect, bottomRightRect);
     distributeVertically(topLeftRect, bottomLeftRect);
     distributeVertically(topRightRect, bottomRightRect);
 
     qreal tx1 = 0.0,
           tx2 = 0.0,
           ty1 = 0.0,
           ty2 = 0.0;
 
     m_shadowQuads.clear();
 
     if (topLeftRect.isValid()) {
         tx1 = 0.0;
         ty1 = 0.0;
         tx2 = topLeftRect.width() / width;
         ty2 = topLeftRect.height() / height;
         WindowQuad topLeftQuad(WindowQuadShadow);
         topLeftQuad[0] = WindowVertex(topLeftRect.left(),  topLeftRect.top(),    tx1, ty1);
         topLeftQuad[1] = WindowVertex(topLeftRect.right(), topLeftRect.top(),    tx2, ty1);
         topLeftQuad[2] = WindowVertex(topLeftRect.right(), topLeftRect.bottom(), tx2, ty2);
         topLeftQuad[3] = WindowVertex(topLeftRect.left(),  topLeftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topLeftQuad);
     }
 
     if (topRightRect.isValid()) {
         tx1 = 1.0 - topRightRect.width() / width;
         ty1 = 0.0;
         tx2 = 1.0;
         ty2 = topRightRect.height() / height;
         WindowQuad topRightQuad(WindowQuadShadow);
         topRightQuad[0] = WindowVertex(topRightRect.left(),  topRightRect.top(),    tx1, ty1);
         topRightQuad[1] = WindowVertex(topRightRect.right(), topRightRect.top(),    tx2, ty1);
         topRightQuad[2] = WindowVertex(topRightRect.right(), topRightRect.bottom(), tx2, ty2);
         topRightQuad[3] = WindowVertex(topRightRect.left(),  topRightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topRightQuad);
     }
 
     if (bottomRightRect.isValid()) {
         tx1 = 1.0 - bottomRightRect.width() / width;
         tx2 = 1.0;
         ty1 = 1.0 - bottomRightRect.height() / height;
         ty2 = 1.0;
         WindowQuad bottomRightQuad(WindowQuadShadow);
         bottomRightQuad[0] = WindowVertex(bottomRightRect.left(),  bottomRightRect.top(),    tx1, ty1);
         bottomRightQuad[1] = WindowVertex(bottomRightRect.right(), bottomRightRect.top(),    tx2, ty1);
         bottomRightQuad[2] = WindowVertex(bottomRightRect.right(), bottomRightRect.bottom(), tx2, ty2);
         bottomRightQuad[3] = WindowVertex(bottomRightRect.left(),  bottomRightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomRightQuad);
     }
 
     if (bottomLeftRect.isValid()) {
         tx1 = 0.0;
         tx2 = bottomLeftRect.width() / width;
         ty1 = 1.0 - bottomLeftRect.height() / height;
         ty2 = 1.0;
         WindowQuad bottomLeftQuad(WindowQuadShadow);
         bottomLeftQuad[0] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.top(),    tx1, ty1);
         bottomLeftQuad[1] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.top(),    tx2, ty1);
         bottomLeftQuad[2] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.bottom(), tx2, ty2);
         bottomLeftQuad[3] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomLeftQuad);
     }
 
     QRectF topRect(
         QPointF(topLeftRect.right(), outerRect.top()),
         QPointF(topRightRect.left(), outerRect.top() + top.height()));
 
     QRectF rightRect(
         QPointF(outerRect.right() - right.width(), topRightRect.bottom()),
         QPointF(outerRect.right(), bottomRightRect.top()));
 
     QRectF bottomRect(
         QPointF(bottomLeftRect.right(), outerRect.bottom() - bottom.height()),
         QPointF(bottomRightRect.left(), outerRect.bottom()));
 
     QRectF leftRect(
         QPointF(outerRect.left(), topLeftRect.bottom()),
         QPointF(outerRect.left() + left.width(), bottomLeftRect.top()));
 
     // Re-distribute left/right and top/bottom shadow tiles so they don't
     // overlap when the window is too small. Please notice that we don't
     // fix overlaps between left/top(left/bottom, right/top, and so on)
     // corner tiles because corresponding counter parts won't be valid when
     // the window is too small, which means they won't be rendered.
     distributeHorizontally(leftRect, rightRect);
     distributeVertically(topRect, bottomRect);
 
     if (topRect.isValid()) {
         tx1 = shadowMargins.left() / width;
         ty1 = 0.0;
         tx2 = tx1 + top.width() / width;
         ty2 = topRect.height() / height;
         WindowQuad topQuad(WindowQuadShadow);
         topQuad[0] = WindowVertex(topRect.left(),  topRect.top(),    tx1, ty1);
         topQuad[1] = WindowVertex(topRect.right(), topRect.top(),    tx2, ty1);
         topQuad[2] = WindowVertex(topRect.right(), topRect.bottom(), tx2, ty2);
         topQuad[3] = WindowVertex(topRect.left(),  topRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topQuad);
     }
 
     if (rightRect.isValid()) {
         tx1 = 1.0 - rightRect.width() / width;
         ty1 = shadowMargins.top() / height;
         tx2 = 1.0;
         ty2 = ty1 + right.height() / height;
         WindowQuad rightQuad(WindowQuadShadow);
         rightQuad[0] = WindowVertex(rightRect.left(),  rightRect.top(),    tx1, ty1);
         rightQuad[1] = WindowVertex(rightRect.right(), rightRect.top(),    tx2, ty1);
         rightQuad[2] = WindowVertex(rightRect.right(), rightRect.bottom(), tx2, ty2);
         rightQuad[3] = WindowVertex(rightRect.left(),  rightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(rightQuad);
     }
 
     if (bottomRect.isValid()) {
         tx1 = shadowMargins.left() / width;
         ty1 = 1.0 - bottomRect.height() / height;
         tx2 = tx1 + bottom.width() / width;
         ty2 = 1.0;
         WindowQuad bottomQuad(WindowQuadShadow);
         bottomQuad[0] = WindowVertex(bottomRect.left(),  bottomRect.top(),    tx1, ty1);
         bottomQuad[1] = WindowVertex(bottomRect.right(), bottomRect.top(),    tx2, ty1);
         bottomQuad[2] = WindowVertex(bottomRect.right(), bottomRect.bottom(), tx2, ty2);
         bottomQuad[3] = WindowVertex(bottomRect.left(),  bottomRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomQuad);
     }
 
     if (leftRect.isValid()) {
         tx1 = 0.0;
         ty1 = shadowMargins.top() / height;
         tx2 = leftRect.width() / width;
         ty2 = ty1 + left.height() / height;
         WindowQuad leftQuad(WindowQuadShadow);
         leftQuad[0] = WindowVertex(leftRect.left(),  leftRect.top(),    tx1, ty1);
         leftQuad[1] = WindowVertex(leftRect.right(), leftRect.top(),    tx2, ty1);
         leftQuad[2] = WindowVertex(leftRect.right(), leftRect.bottom(), tx2, ty2);
         leftQuad[3] = WindowVertex(leftRect.left(),  leftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(leftQuad);
     }
 }
 
 bool SceneOpenGLShadow::prepareBackend()
 {
     if (hasDecorationShadow()) {
         // simplifies a lot by going directly to
         Scene *scene = Compositor::self()->scene();
         scene->makeOpenGLContextCurrent();
         m_texture = DecorationShadowTextureCache::instance().getTexture(this);
 
         return true;
     }
     const QSize top(shadowPixmap(ShadowElementTop).size());
     const QSize topRight(shadowPixmap(ShadowElementTopRight).size());
     const QSize right(shadowPixmap(ShadowElementRight).size());
     const QSize bottom(shadowPixmap(ShadowElementBottom).size());
     const QSize bottomLeft(shadowPixmap(ShadowElementBottomLeft).size());
     const QSize left(shadowPixmap(ShadowElementLeft).size());
     const QSize topLeft(shadowPixmap(ShadowElementTopLeft).size());
     const QSize bottomRight(shadowPixmap(ShadowElementBottomRight).size());
 
     const int width = std::max({topLeft.width(), left.width(), bottomLeft.width()}) +
                       std::max(top.width(), bottom.width()) +
                       std::max({topRight.width(), right.width(), bottomRight.width()});
     const int height = std::max({topLeft.height(), top.height(), topRight.height()}) +
                        std::max(left.height(), right.height()) +
                        std::max({bottomLeft.height(), bottom.height(), bottomRight.height()});
 
     if (width == 0 || height == 0) {
         return false;
     }
 
     QImage image(width, height, QImage::Format_ARGB32);
     image.fill(Qt::transparent);
 
     const int innerRectTop = std::max({topLeft.height(), top.height(), topRight.height()});
     const int innerRectLeft = std::max({topLeft.width(), left.width(), bottomLeft.width()});
 
     QPainter p;
     p.begin(&image);
 
     p.drawPixmap(0, 0, shadowPixmap(ShadowElementTopLeft));
     p.drawPixmap(innerRectLeft, 0, shadowPixmap(ShadowElementTop));
     p.drawPixmap(width - topRight.width(), 0, shadowPixmap(ShadowElementTopRight));
 
     p.drawPixmap(0, innerRectTop, shadowPixmap(ShadowElementLeft));
     p.drawPixmap(width - right.width(), innerRectTop, shadowPixmap(ShadowElementRight));
 
     p.drawPixmap(0, height - bottomLeft.height(), shadowPixmap(ShadowElementBottomLeft));
     p.drawPixmap(innerRectLeft, height - bottom.height(), shadowPixmap(ShadowElementBottom));
     p.drawPixmap(width - bottomRight.width(), height - bottomRight.height(), shadowPixmap(ShadowElementBottomRight));
 
     p.end();
 
     // Check if the image is alpha-only in practice, and if so convert it to an 8-bpp format
     if (!GLPlatform::instance()->isGLES() && GLTexture::supportsSwizzle() && GLTexture::supportsFormatRG()) {
         QImage alphaImage(image.size(), QImage::Format_Indexed8); // Change to Format_Alpha8 w/ Qt 5.5
         bool alphaOnly = true;
 
         for (ptrdiff_t y = 0; alphaOnly && y < image.height(); y++) {
             const uint32_t * const src = reinterpret_cast<const uint32_t *>(image.scanLine(y));
             uint8_t * const dst = reinterpret_cast<uint8_t *>(alphaImage.scanLine(y));
 
             for (ptrdiff_t x = 0; x < image.width(); x++) {
                 if (src[x] & 0x00ffffff)
                     alphaOnly = false;
 
                 dst[x] = qAlpha(src[x]);
             }
         }
 
         if (alphaOnly) {
             image = alphaImage;
         }
     }
 
     Scene *scene = Compositor::self()->scene();
     scene->makeOpenGLContextCurrent();
     m_texture = QSharedPointer<GLTexture>::create(image);
 
     if (m_texture->internalFormat() == GL_R8) {
         // Swizzle red to alpha and all other channels to zero
         m_texture->bind();
         m_texture->setSwizzle(GL_ZERO, GL_ZERO, GL_ZERO, GL_RED);
     }
 
     return true;
 }
 
 SceneOpenGLDecorationRenderer::SceneOpenGLDecorationRenderer(Decoration::DecoratedClientImpl *client)
     : Renderer(client)
     , m_texture()
 {
     connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
 }
 
 SceneOpenGLDecorationRenderer::~SceneOpenGLDecorationRenderer()
 {
     if (Scene *scene = Compositor::self()->scene()) {
         scene->makeOpenGLContextCurrent();
     }
 }
 
 // Rotates the given source rect 90° counter-clockwise,
 // and flips it vertically
 static QImage rotate(const QImage &srcImage, const QRect &srcRect)
 {
     auto dpr = srcImage.devicePixelRatio();
     QImage image(srcRect.height() * dpr, srcRect.width() * dpr, srcImage.format());
     image.setDevicePixelRatio(dpr);
     const QPoint srcPoint(srcRect.x() * dpr, srcRect.y() * dpr);
 
     const uint32_t *src = reinterpret_cast<const uint32_t *>(srcImage.bits());
     uint32_t *dst = reinterpret_cast<uint32_t *>(image.bits());
 
     for (int x = 0; x < image.width(); x++) {
         const uint32_t *s = src + (srcPoint.y() + x) * srcImage.width() + srcPoint.x();
         uint32_t *d = dst + x;
 
         for (int y = 0; y < image.height(); y++) {
             *d = s[y];
             d += image.width();
         }
     }
 
     return image;
 }
 
 void SceneOpenGLDecorationRenderer::render()
 {
     const QRegion scheduled = getScheduled();
     const bool dirty = areImageSizesDirty();
     if (scheduled.isEmpty() && !dirty) {
         return;
     }
     if (dirty) {
         resizeTexture();
         resetImageSizesDirty();
     }
 
     if (!m_texture) {
         // for invalid sizes we get no texture, see BUG 361551
         return;
     }
 
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
 
     const QRect geometry = dirty ? QRect(QPoint(0, 0), client()->client()->size()) : scheduled.boundingRect();
 
     auto renderPart = [this](const QRect &geo, const QRect &partRect, const QPoint &offset, bool rotated = false) {
         if (!geo.isValid()) {
             return;
         }
         QImage image = renderToImage(geo);
         if (rotated) {
             // TODO: get this done directly when rendering to the image
             image = rotate(image, QRect(geo.topLeft() - partRect.topLeft(), geo.size()));
         }
         m_texture->update(image, (geo.topLeft() - partRect.topLeft() + offset) * image.devicePixelRatio());
     };
     renderPart(left.intersected(geometry), left, QPoint(0, top.height() + bottom.height() + 2), true);
     renderPart(top.intersected(geometry), top, QPoint(0, 0));
     renderPart(right.intersected(geometry), right, QPoint(0, top.height() + bottom.height() + left.width() + 3), true);
     renderPart(bottom.intersected(geometry), bottom, QPoint(0, top.height() + 1));
 }
 
 static int align(int value, int align)
 {
     return (value + align - 1) & ~(align - 1);
 }
 
 void SceneOpenGLDecorationRenderer::resizeTexture()
 {
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
     QSize size;
 
     size.rwidth() = qMax(qMax(top.width(), bottom.width()),
                          qMax(left.height(), right.height()));
     size.rheight() = top.height() + bottom.height() +
                      left.width() + right.width() + 3;
 
     size.rwidth() = align(size.width(), 128);
 
     size *= client()->client()->screenScale();
     if (m_texture && m_texture->size() == size)
         return;
 
     if (!size.isEmpty()) {
         m_texture.reset(new GLTexture(GL_RGBA8, size.width(), size.height()));
         m_texture->setYInverted(true);
         m_texture->setWrapMode(GL_CLAMP_TO_EDGE);
         m_texture->clear();
     } else {
         m_texture.reset();
     }
 }
 
 void SceneOpenGLDecorationRenderer::reparent(Deleted *deleted)
 {
     render();
     Renderer::reparent(deleted);
 }
 
 
 OpenGLFactory::OpenGLFactory(QObject *parent)
     : SceneFactory(parent)
 {
 }
 
 OpenGLFactory::~OpenGLFactory() = default;
 
 Scene *OpenGLFactory::create(QObject *parent) const
 {
     qCDebug(KWIN_OPENGL) << "Initializing OpenGL compositing";
 
     // Some broken drivers crash on glXQuery() so to prevent constant KWin crashes:
     if (kwinApp()->platform()->openGLCompositingIsBroken()) {
         qCWarning(KWIN_OPENGL) << "KWin has detected that your OpenGL library is unsafe to use";
         return nullptr;
     }
     kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreInit);
     auto s = SceneOpenGL::createScene(parent);
     kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostInit);
     if (s && s->initFailed()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 } // namespace
diff --git a/plugins/scenes/opengl/scene_opengl.h b/plugins/scenes/opengl/scene_opengl.h
index af4309bc5..b9978c964 100644
--- a/plugins/scenes/opengl/scene_opengl.h
+++ b/plugins/scenes/opengl/scene_opengl.h
@@ -1,358 +1,357 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 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_SCENE_OPENGL_H
 #define KWIN_SCENE_OPENGL_H
 
 #include "scene.h"
 #include "shadow.h"
 
 #include "kwinglutils.h"
 
 #include "decorations/decorationrenderer.h"
 #include "platformsupport/scenes/opengl/backend.h"
 
 namespace KWin
 {
 class LanczosFilter;
 class OpenGLBackend;
 class SyncManager;
 class SyncObject;
 
 class KWIN_EXPORT SceneOpenGL
     : public Scene
 {
     Q_OBJECT
 public:
     class EffectFrame;
     class Window;
     ~SceneOpenGL() override;
     bool initFailed() const override;
     bool hasPendingFlush() const override;
     qint64 paint(QRegion damage, ToplevelList windows) override;
     Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame) override;
     Shadow *createShadow(Toplevel *toplevel) override;
     void screenGeometryChanged(const QSize &size) override;
     OverlayWindow *overlayWindow() const override;
     bool usesOverlayWindow() const override;
     bool blocksForRetrace() const override;
-    bool syncsToVBlank() const override;
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
     Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
     void triggerFence() override;
     virtual QMatrix4x4 projectionMatrix() const = 0;
     bool animationsSupported() const override;
 
     void insertWait();
 
     void idle() override;
 
     bool debug() const { return m_debug; }
     void initDebugOutput();
 
     /**
      * @brief Factory method to create a backend specific texture.
      *
      * @return :SceneOpenGL::Texture*
      */
     SceneOpenGLTexture *createTexture();
 
     OpenGLBackend *backend() const {
         return m_backend;
     }
 
     QVector<QByteArray> openGLPlatformInterfaceExtensions() const override;
 
     static SceneOpenGL *createScene(QObject *parent);
 
 protected:
     SceneOpenGL(OpenGLBackend *backend, QObject *parent = nullptr);
     void paintBackground(QRegion region) override;
     void extendPaintRegion(QRegion &region, bool opaqueFullscreen) override;
     QMatrix4x4 transformation(int mask, const ScreenPaintData &data) const;
     void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data) override;
     void paintEffectQuickView(EffectQuickView *w) override;
 
     void handleGraphicsReset(GLenum status);
 
     virtual void doPaintBackground(const QVector<float> &vertices) = 0;
     virtual void updateProjectionMatrix() = 0;
 
 protected:
     bool init_ok;
 private:
     bool viewportLimitsMatched(const QSize &size) const;
 private:
     bool m_debug;
     OpenGLBackend *m_backend;
     SyncManager *m_syncManager;
     SyncObject *m_currentFence;
 };
 
 class SceneOpenGL2 : public SceneOpenGL
 {
     Q_OBJECT
 public:
     explicit SceneOpenGL2(OpenGLBackend *backend, QObject *parent = nullptr);
     ~SceneOpenGL2() override;
     CompositingType compositingType() const override {
         return OpenGL2Compositing;
     }
 
     static bool supported(OpenGLBackend *backend);
 
     QMatrix4x4 projectionMatrix() const override { return m_projectionMatrix; }
     QMatrix4x4 screenProjectionMatrix() const override { return m_screenProjectionMatrix; }
 
 protected:
     void paintSimpleScreen(int mask, QRegion region) override;
     void paintGenericScreen(int mask, ScreenPaintData data) override;
     void doPaintBackground(const QVector< float >& vertices) override;
     Scene::Window *createWindow(Toplevel *t) override;
     void finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data) override;
     void updateProjectionMatrix() override;
     void paintCursor() override;
 
 private:
     void performPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data);
     QMatrix4x4 createProjectionMatrix() const;
 
 private:
     LanczosFilter *m_lanczosFilter;
     QScopedPointer<GLTexture> m_cursorTexture;
     QMatrix4x4 m_projectionMatrix;
     QMatrix4x4 m_screenProjectionMatrix;
     GLuint vao;
 };
 
 class SceneOpenGL::Window
     : public Scene::Window
 {
 public:
     ~Window() override;
     bool beginRenderWindow(int mask, const QRegion &region, WindowPaintData &data);
     void performPaint(int mask, QRegion region, WindowPaintData data) override = 0;
     void endRenderWindow();
     bool bindTexture();
     void setScene(SceneOpenGL *scene) {
         m_scene = scene;
     }
 
 protected:
     WindowPixmap* createWindowPixmap() override;
     Window(Toplevel* c);
     enum TextureType {
         Content,
         Decoration,
         Shadow
     };
 
     QMatrix4x4 transformation(int mask, const WindowPaintData &data) const;
     GLTexture *getDecorationTexture() const;
 
 protected:
     SceneOpenGL *m_scene;
     bool m_hardwareClipping;
 };
 
 class OpenGLWindowPixmap;
 
 class SceneOpenGL2Window : public SceneOpenGL::Window
 {
 public:
     enum Leaf { ShadowLeaf = 0, DecorationLeaf, ContentLeaf, PreviousContentLeaf, LeafCount };
 
     struct LeafNode
     {
         LeafNode()
             : texture(nullptr),
               firstVertex(0),
               vertexCount(0),
               opacity(1.0),
               hasAlpha(false),
               coordinateType(UnnormalizedCoordinates)
         {
         }
 
         GLTexture *texture;
         int firstVertex;
         int vertexCount;
         float opacity;
         bool hasAlpha;
         TextureCoordinateType coordinateType;
     };
 
     explicit SceneOpenGL2Window(Toplevel *c);
     ~SceneOpenGL2Window() override;
 
 protected:
     QMatrix4x4 modelViewProjectionMatrix(int mask, const WindowPaintData &data) const;
     QVector4D modulate(float opacity, float brightness) const;
     void setBlendEnabled(bool enabled);
     void setupLeafNodes(LeafNode *nodes, const WindowQuadList *quads, const WindowPaintData &data);
     void performPaint(int mask, QRegion region, WindowPaintData data) override;
 
 private:
     void renderSubSurface(GLShader *shader, const QMatrix4x4 &mvp, const QMatrix4x4 &windowMatrix, OpenGLWindowPixmap *pixmap, const QRegion &region, bool hardwareClipping);
     /**
      * Whether prepareStates enabled blending and restore states should disable again.
      */
     bool m_blendingEnabled;
 };
 
 class OpenGLWindowPixmap : public WindowPixmap
 {
 public:
     explicit OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL *scene);
     ~OpenGLWindowPixmap() override;
     SceneOpenGLTexture *texture() const;
     bool bind();
     bool isValid() const override;
 protected:
     WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface) override;
 private:
     explicit OpenGLWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene);
     QScopedPointer<SceneOpenGLTexture> m_texture;
     SceneOpenGL *m_scene;
 };
 
 class SceneOpenGL::EffectFrame
     : public Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene);
     ~EffectFrame() override;
 
     void free() override;
     void freeIconFrame() override;
     void freeTextFrame() override;
     void freeSelection() override;
 
     void render(QRegion region, double opacity, double frameOpacity) override;
 
     void crossFadeIcon() override;
     void crossFadeText() override;
 
     static void cleanup();
 
 private:
     void updateTexture();
     void updateTextTexture();
 
     GLTexture *m_texture;
     GLTexture *m_textTexture;
     GLTexture *m_oldTextTexture;
     QPixmap *m_textPixmap; // need to keep the pixmap around to workaround some driver problems
     GLTexture *m_iconTexture;
     GLTexture *m_oldIconTexture;
     GLTexture *m_selectionTexture;
     GLVertexBuffer *m_unstyledVBO;
     SceneOpenGL *m_scene;
 
     static GLTexture* m_unstyledTexture;
     static QPixmap* m_unstyledPixmap; // need to keep the pixmap around to workaround some driver problems
     static void updateUnstyledTexture(); // Update OpenGL unstyled frame texture
 };
 
 /**
  * @short OpenGL implementation of Shadow.
  *
  * This class extends Shadow by the Elements required for OpenGL rendering.
  * @author Martin Gräßlin <mgraesslin@kde.org>
  */
 class SceneOpenGLShadow
     : public Shadow
 {
 public:
     explicit SceneOpenGLShadow(Toplevel *toplevel);
     ~SceneOpenGLShadow() override;
 
     GLTexture *shadowTexture() {
         return m_texture.data();
     }
 protected:
     void buildQuads() override;
     bool prepareBackend() override;
 private:
     QSharedPointer<GLTexture> m_texture;
 };
 
 class SceneOpenGLDecorationRenderer : public Decoration::Renderer
 {
     Q_OBJECT
 public:
     enum class DecorationPart : int {
         Left,
         Top,
         Right,
         Bottom,
         Count
     };
     explicit SceneOpenGLDecorationRenderer(Decoration::DecoratedClientImpl *client);
     ~SceneOpenGLDecorationRenderer() override;
 
     void render() override;
     void reparent(Deleted *deleted) override;
 
     GLTexture *texture() {
         return m_texture.data();
     }
     GLTexture *texture() const {
         return m_texture.data();
     }
 
 private:
     void resizeTexture();
     QScopedPointer<GLTexture> m_texture;
 };
 
 inline bool SceneOpenGL::hasPendingFlush() const
 {
     return m_backend->hasPendingFlush();
 }
 
 inline bool SceneOpenGL::usesOverlayWindow() const
 {
     return m_backend->usesOverlayWindow();
 }
 
 inline SceneOpenGLTexture* OpenGLWindowPixmap::texture() const
 {
     return m_texture.data();
 }
 
 class KWIN_EXPORT OpenGLFactory : public SceneFactory
 {
     Q_OBJECT
     Q_INTERFACES(KWin::SceneFactory)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Scene" FILE "opengl.json")
 
 public:
     explicit OpenGLFactory(QObject *parent = nullptr);
     ~OpenGLFactory() override;
 
     Scene *create(QObject *parent = nullptr) const override;
 };
 
 } // namespace
 
 #endif
diff --git a/scene.cpp b/scene.cpp
index ce186a4d0..fdc135c7b 100644
--- a/scene.cpp
+++ b/scene.cpp
@@ -1,1155 +1,1150 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@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/>.
 *********************************************************************/
 
 /*
  The base class for compositing, implementing shared functionality
  between the OpenGL and XRender backends.
 
  Design:
 
  When compositing is turned on, XComposite extension is used to redirect
  drawing of windows to pixmaps and XDamage extension is used to get informed
  about damage (changes) to window contents. This code is mostly in composite.cpp .
 
  Compositor::performCompositing() starts one painting pass. Painting is done
  by painting the screen, which in turn paints every window. Painting can be affected
  using effects, which are chained. E.g. painting a screen means that actually
  paintScreen() of the first effect is called, which possibly does modifications
  and calls next effect's paintScreen() and so on, until Scene::finalPaintScreen()
  is called.
 
  There are 3 phases of every paint (not necessarily done together):
  The pre-paint phase, the paint phase and the post-paint phase.
 
  The pre-paint phase is used to find out about how the painting will be actually
  done (i.e. what the effects will do). For example when only a part of the screen
  needs to be updated and no effect will do any transformation it is possible to use
  an optimized paint function. How the painting will be done is controlled
  by the mask argument, see PAINT_WINDOW_* and PAINT_SCREEN_* flags in scene.h .
  For example an effect that decides to paint a normal windows as translucent
  will need to modify the mask in its prePaintWindow() to include
  the PAINT_WINDOW_TRANSLUCENT flag. The paintWindow() function will then get
  the mask with this flag turned on and will also paint using transparency.
 
  The paint pass does the actual painting, based on the information collected
  using the pre-paint pass. After running through the effects' paintScreen()
  either paintGenericScreen() or optimized paintSimpleScreen() are called.
  Those call paintWindow() on windows (not necessarily all), possibly using
  clipping to optimize performance and calling paintWindow() first with only
  PAINT_WINDOW_OPAQUE to paint the opaque parts and then later
  with PAINT_WINDOW_TRANSLUCENT to paint the transparent parts. Function
  paintWindow() again goes through effects' paintWindow() until
  finalPaintWindow() is called, which calls the window's performPaint() to
  do the actual painting.
 
  The post-paint can be used for cleanups and is also used for scheduling
  repaints during the next painting pass for animations. Effects wanting to
  repaint certain parts can manually damage them during post-paint and repaint
  of these parts will be done during the next paint pass.
 
 */
 
 #include "scene.h"
 
 #include <QQuickWindow>
 #include <QVector2D>
 
 #include "x11client.h"
 #include "deleted.h"
 #include "effects.h"
 #include "overlaywindow.h"
 #include "screens.h"
 #include "shadow.h"
 #include "wayland_server.h"
 
 #include "thumbnailitem.h"
 
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/subcompositor_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 namespace KWin
 {
 
 //****************************************
 // Scene
 //****************************************
 
 Scene::Scene(QObject *parent)
     : QObject(parent)
 {
     last_time.invalidate(); // Initialize the timer
 }
 
 Scene::~Scene()
 {
     Q_ASSERT(m_windows.isEmpty());
 }
 
 // returns mask and possibly modified region
 void Scene::paintScreen(int* mask, const QRegion &damage, const QRegion &repaint,
                         QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection, const QRect &outputGeometry)
 {
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     *mask = (damage == displayRegion) ? 0 : PAINT_SCREEN_REGION;
 
     updateTimeDiff();
     // preparation step
     static_cast<EffectsHandlerImpl*>(effects)->startPaint();
 
     QRegion region = damage;
 
     ScreenPrePaintData pdata;
     pdata.mask = *mask;
     pdata.paint = region;
 
     effects->prePaintScreen(pdata, time_diff);
     *mask = pdata.mask;
     region = pdata.paint;
 
     if (*mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) {
         // Region painting is not possible with transformations,
         // because screen damage doesn't match transformed positions.
         *mask &= ~PAINT_SCREEN_REGION;
         region = infiniteRegion();
     } else if (*mask & PAINT_SCREEN_REGION) {
         // make sure not to go outside visible screen
         region &= displayRegion;
     } else {
         // whole screen, not transformed, force region to be full
         region = displayRegion;
     }
 
     painted_region = region;
     repaint_region = repaint;
 
     if (*mask & PAINT_SCREEN_BACKGROUND_FIRST) {
         paintBackground(region);
     }
 
     ScreenPaintData data(projection, outputGeometry);
     effects->paintScreen(*mask, region, data);
 
     foreach (Window *w, stacking_order) {
         effects->postPaintWindow(effectWindow(w));
     }
 
     effects->postPaintScreen();
 
     // make sure not to go outside of the screen area
     *updateRegion = damaged_region;
     *validRegion = (region | painted_region) & displayRegion;
 
     repaint_region = QRegion();
     damaged_region = QRegion();
 
     // make sure all clipping is restored
     Q_ASSERT(!PaintClipper::clip());
 }
 
 // Compute time since the last painting pass.
 void Scene::updateTimeDiff()
 {
     if (!last_time.isValid()) {
         // Painting has been idle (optimized out) for some time,
         // which means time_diff would be huge and would break animations.
         // Simply set it to one (zero would mean no change at all and could
         // cause problems).
         time_diff = 1;
         last_time.start();
     } else
 
     time_diff = last_time.restart();
 
     if (time_diff < 0)   // check time rollback
         time_diff = 1;
 }
 
 // Painting pass is optimized away.
 void Scene::idle()
 {
     // Don't break time since last paint for the next pass.
     last_time.invalidate();
 }
 
 // the function that'll be eventually called by paintScreen() above
 void Scene::finalPaintScreen(int mask, QRegion region, ScreenPaintData& data)
 {
     if (mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS))
         paintGenericScreen(mask, data);
     else
         paintSimpleScreen(mask, region);
 }
 
 // The generic painting code that can handle even transformations.
 // It simply paints bottom-to-top.
 void Scene::paintGenericScreen(int orig_mask, ScreenPaintData)
 {
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintBackground(infiniteRegion());
     }
     QVector<Phase2Data> phase2;
     phase2.reserve(stacking_order.size());
     foreach (Window * w, stacking_order) { // bottom to top
         Toplevel* topw = w->window();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         topw->resetRepaints();
 
         WindowPrePaintData data;
         data.mask = orig_mask | (w->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         w->resetPaintingEnabled();
         data.paint = infiniteRegion(); // no clipping, so doesn't really matter
         data.clip = QRegion();
         data.quads = w->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(w), data, time_diff);
 #if !defined(QT_NO_DEBUG)
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!w->isPaintingEnabled()) {
             continue;
         }
         phase2.append({w, infiniteRegion(), data.clip, data.mask, data.quads});
     }
 
     foreach (const Phase2Data & d, phase2) {
         paintWindow(d.window, d.mask, d.region, d.quads);
     }
 
     const QSize &screenSize = screens()->size();
     damaged_region = QRegion(0, 0, screenSize.width(), screenSize.height());
 }
 
 // The optimized case without any transformations at all.
 // It can paint only the requested region and can use clipping
 // to reduce painting and improve performance.
 void Scene::paintSimpleScreen(int orig_mask, QRegion region)
 {
     Q_ASSERT((orig_mask & (PAINT_SCREEN_TRANSFORMED
                          | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) == 0);
     QVector<Phase2Data> phase2data;
     phase2data.reserve(stacking_order.size());
 
     QRegion dirtyArea = region;
     bool opaqueFullscreen(false);
     for (int i = 0;  // do prePaintWindow bottom to top
             i < stacking_order.count();
             ++i) {
         Window* w = stacking_order[ i ];
         Toplevel* topw = w->window();
         WindowPrePaintData data;
         data.mask = orig_mask | (w->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         w->resetPaintingEnabled();
         data.paint = region;
         data.paint |= topw->repaints();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         topw->resetRepaints();
 
         // Clip out the decoration for opaque windows; the decoration is drawn in the second pass
         opaqueFullscreen = false; // TODO: do we care about unmanged windows here (maybe input windows?)
         if (w->isOpaque()) {
             AbstractClient *c = dynamic_cast<AbstractClient*>(topw);
             if (c) {
                 opaqueFullscreen = c->isFullScreen();
             }
             X11Client *cc = dynamic_cast<X11Client *>(c);
             // the window is fully opaque
             if (cc && cc->decorationHasAlpha()) {
                 // decoration uses alpha channel, so we may not exclude it in clipping
                 data.clip = w->clientShape().translated(w->x(), w->y());
             } else {
                 // decoration is fully opaque
                 if (c && c->isShade()) {
                     data.clip = QRegion();
                 } else {
                     data.clip = w->shape().translated(w->x(), w->y());
                 }
             }
         } else if (topw->hasAlpha() && topw->opacity() == 1.0) {
             // the window is partially opaque
             data.clip = (w->clientShape() & topw->opaqueRegion().translated(topw->clientPos())).translated(w->x(), w->y());
         } else {
             data.clip = QRegion();
         }
         data.quads = w->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(w), data, time_diff);
 #if !defined(QT_NO_DEBUG)
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!w->isPaintingEnabled()) {
             continue;
         }
         dirtyArea |= data.paint;
         // Schedule the window for painting
         phase2data.append({w, data.paint, data.clip, data.mask, data.quads});
     }
 
     // Save the part of the repaint region that's exclusively rendered to
     // bring a reused back buffer up to date. Then union the dirty region
     // with the repaint region.
     const QRegion repaintClip = repaint_region - dirtyArea;
     dirtyArea |= repaint_region;
 
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     bool fullRepaint(dirtyArea == displayRegion); // spare some expensive region operations
     if (!fullRepaint) {
         extendPaintRegion(dirtyArea, opaqueFullscreen);
         fullRepaint = (dirtyArea == displayRegion);
     }
 
     QRegion allclips, upperTranslucentDamage;
     upperTranslucentDamage = repaint_region;
 
     // This is the occlusion culling pass
     for (int i = phase2data.count() - 1; i >= 0; --i) {
         Phase2Data *data = &phase2data[i];
 
         if (fullRepaint)
             data->region = displayRegion;
         else
             data->region |= upperTranslucentDamage;
 
         // subtract the parts which will possibly been drawn as part of
         // a higher opaque window
         data->region -= allclips;
 
         // Here we rely on WindowPrePaintData::setTranslucent() to remove
         // the clip if needed.
         if (!data->clip.isEmpty() && !(data->mask & PAINT_WINDOW_TRANSLUCENT)) {
             // clip away the opaque regions for all windows below this one
             allclips |= data->clip;
             // extend the translucent damage for windows below this by remaining (translucent) regions
             if (!fullRepaint)
                 upperTranslucentDamage |= data->region - data->clip;
         } else if (!fullRepaint) {
             upperTranslucentDamage |= data->region;
         }
     }
 
     QRegion paintedArea;
     // Fill any areas of the root window not covered by opaque windows
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintedArea = dirtyArea - allclips;
         paintBackground(paintedArea);
     }
 
     // Now walk the list bottom to top and draw the windows.
     for (int i = 0; i < phase2data.count(); ++i) {
         Phase2Data *data = &phase2data[i];
 
         // add all regions which have been drawn so far
         paintedArea |= data->region;
         data->region = paintedArea;
 
         paintWindow(data->window, data->mask, data->region, data->quads);
     }
 
     if (fullRepaint) {
         painted_region = displayRegion;
         damaged_region = displayRegion;
     } else {
         painted_region |= paintedArea;
 
         // Clip the repainted region from the damaged region.
         // It's important that we don't add the union of the damaged region
         // and the repainted region to the damage history. Otherwise the
         // repaint region will grow with every frame until it eventually
         // covers the whole back buffer, at which point we're always doing
         // full repaints.
         damaged_region = paintedArea - repaintClip;
     }
 }
 
 void Scene::addToplevel(Toplevel *c)
 {
     Q_ASSERT(!m_windows.contains(c));
     Scene::Window *w = createWindow(c);
     m_windows[ c ] = w;
     connect(c, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SLOT(windowGeometryShapeChanged(KWin::Toplevel*)));
     connect(c, SIGNAL(windowClosed(KWin::Toplevel*,KWin::Deleted*)), SLOT(windowClosed(KWin::Toplevel*,KWin::Deleted*)));
     //A change of scale won't affect the geometry in compositor co-ordinates, but will affect the window quads.
     if (c->surface()) {
         connect(c->surface(), &KWayland::Server::SurfaceInterface::scaleChanged, this, std::bind(&Scene::windowGeometryShapeChanged, this, c));
     }
     connect(c, &Toplevel::screenScaleChanged, this,
         [this, c] {
             windowGeometryShapeChanged(c);
         }
     );
     c->effectWindow()->setSceneWindow(w);
     c->updateShadow();
     w->updateShadow(c->shadow());
     connect(c, &Toplevel::shadowChanged, this,
         [w] {
             w->invalidateQuadsCache();
         }
     );
 }
 
 void Scene::removeToplevel(Toplevel *toplevel)
 {
     Q_ASSERT(m_windows.contains(toplevel));
     delete m_windows.take(toplevel);
     toplevel->effectWindow()->setSceneWindow(nullptr);
 }
 
 void Scene::windowClosed(Toplevel *toplevel, Deleted *deleted)
 {
     if (!deleted) {
         removeToplevel(toplevel);
         return;
     }
 
     Q_ASSERT(m_windows.contains(toplevel));
     Window *window = m_windows.take(toplevel);
     window->updateToplevel(deleted);
     if (window->shadow()) {
         window->shadow()->setToplevel(deleted);
     }
     m_windows[deleted] = window;
 }
 
 void Scene::windowGeometryShapeChanged(Toplevel *c)
 {
     if (!m_windows.contains(c))    // this is ok, shape is not valid by default
         return;
     Window *w = m_windows[ c ];
     w->discardShape();
 }
 
 void Scene::createStackingOrder(ToplevelList toplevels)
 {
     // TODO: cache the stacking_order in case it has not changed
     foreach (Toplevel *c, toplevels) {
         Q_ASSERT(m_windows.contains(c));
         stacking_order.append(m_windows[ c ]);
     }
 }
 
 void Scene::clearStackingOrder()
 {
     stacking_order.clear();
 }
 
 static Scene::Window *s_recursionCheck = nullptr;
 
 void Scene::paintWindow(Window* w, int mask, QRegion region, WindowQuadList quads)
 {
     // no painting outside visible screen (and no transformations)
     const QSize &screenSize = screens()->size();
     region &= QRect(0, 0, screenSize.width(), screenSize.height());
     if (region.isEmpty())  // completely clipped
         return;
     if (w->window()->isDeleted() && w->window()->skipsCloseAnimation()) {
         // should not get painted
         return;
     }
 
     if (s_recursionCheck == w) {
         return;
     }
 
     WindowPaintData data(w->window()->effectWindow(), screenProjectionMatrix());
     data.quads = quads;
     effects->paintWindow(effectWindow(w), mask, region, data);
     // paint thumbnails on top of window
     paintWindowThumbnails(w, region, data.opacity(), data.brightness(), data.saturation());
     // and desktop thumbnails
     paintDesktopThumbnails(w);
 }
 
 static void adjustClipRegion(AbstractThumbnailItem *item, QRegion &clippingRegion)
 {
     if (item->clip() && item->clipTo()) {
         // the x/y positions of the parent item are not correct. The margins are added, though the size seems fine
         // that's why we have to get the offset by inspecting the anchors properties
         QQuickItem *parentItem = item->clipTo();
         QPointF offset;
         QVariant anchors = parentItem->property("anchors");
         if (anchors.isValid()) {
             if (QObject *anchorsObject = anchors.value<QObject*>()) {
                 offset.setX(anchorsObject->property("leftMargin").toReal());
                 offset.setY(anchorsObject->property("topMargin").toReal());
             }
         }
         QRectF rect = QRectF(parentItem->position() - offset, QSizeF(parentItem->width(), parentItem->height()));
         if (QQuickItem *p = parentItem->parentItem()) {
             rect = p->mapRectToScene(rect);
         }
         clippingRegion &= rect.adjusted(0,0,-1,-1).translated(item->window()->position()).toRect();
     }
 }
 
 void Scene::paintWindowThumbnails(Scene::Window *w, QRegion region, qreal opacity, qreal brightness, qreal saturation)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> >::const_iterator it = wImpl->thumbnails().constBegin();
             it != wImpl->thumbnails().constEnd();
             ++it) {
         if (it.value().isNull()) {
             continue;
         }
         WindowThumbnailItem *item = it.key();
         if (!item->isVisible()) {
             continue;
         }
         EffectWindowImpl *thumb = it.value().data();
         WindowPaintData thumbData(thumb, screenProjectionMatrix());
         thumbData.setOpacity(opacity);
         thumbData.setBrightness(brightness * item->brightness());
         thumbData.setSaturation(saturation * item->saturation());
 
         const QRect visualThumbRect(thumb->expandedGeometry());
 
         QSizeF size = QSizeF(visualThumbRect.size());
         size.scale(QSizeF(item->width(), item->height()), Qt::KeepAspectRatio);
         if (size.width() > visualThumbRect.width() || size.height() > visualThumbRect.height()) {
             size = QSizeF(visualThumbRect.size());
         }
         thumbData.setXScale(size.width() / static_cast<qreal>(visualThumbRect.width()));
         thumbData.setYScale(size.height() / static_cast<qreal>(visualThumbRect.height()));
 
         if (!item->window()) {
             continue;
         }
         const QPointF point = item->mapToScene(item->position());
         qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         x -= thumb->x();
         y -= thumb->y();
         // compensate shadow topleft padding
         x += (thumb->x()-visualThumbRect.x())*thumbData.xScale();
         y += (thumb->y()-visualThumbRect.y())*thumbData.yScale();
         thumbData.setXTranslation(x);
         thumbData.setYTranslation(y);
         int thumbMask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_LANCZOS;
         if (thumbData.opacity() == 1.0) {
             thumbMask |= PAINT_WINDOW_OPAQUE;
         } else {
             thumbMask |= PAINT_WINDOW_TRANSLUCENT;
         }
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         effects->drawWindow(thumb, thumbMask, clippingRegion, thumbData);
     }
 }
 
 void Scene::paintDesktopThumbnails(Scene::Window *w)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QList<DesktopThumbnailItem*>::const_iterator it = wImpl->desktopThumbnails().constBegin();
             it != wImpl->desktopThumbnails().constEnd();
             ++it) {
         DesktopThumbnailItem *item = *it;
         if (!item->isVisible()) {
             continue;
         }
         if (!item->window()) {
             continue;
         }
         s_recursionCheck = w;
 
         ScreenPaintData data;
         const QSize &screenSize = screens()->size();
         QSize size = screenSize;
 
         size.scale(item->width(), item->height(), Qt::KeepAspectRatio);
         data *= QVector2D(size.width() / double(screenSize.width()),
                           size.height() / double(screenSize.height()));
         const QPointF point = item->mapToScene(item->position());
         const qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         const qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         const QRect region = QRect(x, y, item->width(), item->height());
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         data += QPointF(x, y);
         const int desktopMask = PAINT_SCREEN_TRANSFORMED | PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_BACKGROUND_FIRST;
         paintDesktop(item->desktop(), desktopMask, clippingRegion, data);
         s_recursionCheck = nullptr;
     }
 }
 
 void Scene::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     static_cast<EffectsHandlerImpl*>(effects)->paintDesktop(desktop, mask, region, data);
 }
 
 // the function that'll be eventually called by paintWindow() above
 void Scene::finalPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     effects->drawWindow(w, mask, region, data);
 }
 
 // will be eventually called from drawWindow()
 void Scene::finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
         return;
     }
     w->sceneWindow()->performPaint(mask, region, data);
 }
 
 void Scene::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
 {
     Q_UNUSED(region);
     Q_UNUSED(opaqueFullscreen);
 }
 
 bool Scene::blocksForRetrace() const
 {
     return false;
 }
 
-bool Scene::syncsToVBlank() const
-{
-    return false;
-}
-
 void Scene::screenGeometryChanged(const QSize &size)
 {
     if (!overlayWindow()) {
         return;
     }
     overlayWindow()->resize(size);
 }
 
 bool Scene::makeOpenGLContextCurrent()
 {
     return false;
 }
 
 void Scene::doneOpenGLContextCurrent()
 {
 }
 
 void Scene::triggerFence()
 {
 }
 
 QMatrix4x4 Scene::screenProjectionMatrix() const
 {
     return QMatrix4x4();
 }
 
 xcb_render_picture_t Scene::xrenderBufferPicture() const
 {
     return XCB_RENDER_PICTURE_NONE;
 }
 
 QPainter *Scene::scenePainter() const
 {
     return nullptr;
 }
 
 QImage *Scene::qpainterRenderBuffer() const
 {
     return nullptr;
 }
 
 QVector<QByteArray> Scene::openGLPlatformInterfaceExtensions() const
 {
     return QVector<QByteArray>{};
 }
 
 //****************************************
 // Scene::Window
 //****************************************
 
 Scene::Window::Window(Toplevel * c)
     : toplevel(c)
     , filter(ImageFilterFast)
     , m_shadow(nullptr)
     , m_currentPixmap()
     , m_previousPixmap()
     , m_referencePixmapCounter(0)
     , disable_painting(0)
     , shape_valid(false)
     , cached_quad_list(nullptr)
 {
 }
 
 Scene::Window::~Window()
 {
     delete m_shadow;
 }
 
 void Scene::Window::referencePreviousPixmap()
 {
     if (!m_previousPixmap.isNull() && m_previousPixmap->isDiscarded()) {
         m_referencePixmapCounter++;
     }
 }
 
 void Scene::Window::unreferencePreviousPixmap()
 {
     if (m_previousPixmap.isNull() || !m_previousPixmap->isDiscarded()) {
         return;
     }
     m_referencePixmapCounter--;
     if (m_referencePixmapCounter == 0) {
         m_previousPixmap.reset();
     }
 }
 
 void Scene::Window::pixmapDiscarded()
 {
     if (!m_currentPixmap.isNull()) {
         if (m_currentPixmap->isValid()) {
             m_previousPixmap.reset(m_currentPixmap.take());
             m_previousPixmap->markAsDiscarded();
         } else {
             m_currentPixmap.reset();
         }
     }
 }
 
 void Scene::Window::discardShape()
 {
     // it is created on-demand and cached, simply
     // reset the flag
     shape_valid = false;
     invalidateQuadsCache();
 }
 
 // Find out the shape of the window using the XShape extension
 // or if shape is not set then simply it's the window geometry.
 const QRegion &Scene::Window::shape() const
 {
     if (!shape_valid) {
         if (toplevel->shape()) {
             auto cookie = xcb_shape_get_rectangles_unchecked(connection(), toplevel->frameId(), XCB_SHAPE_SK_BOUNDING);
             ScopedCPointer<xcb_shape_get_rectangles_reply_t> reply(xcb_shape_get_rectangles_reply(connection(), cookie, nullptr));
             if (!reply.isNull()) {
                 shape_region = QRegion();
                 auto *rects = xcb_shape_get_rectangles_rectangles(reply.data());
                 for (int i = 0;
                         i < xcb_shape_get_rectangles_rectangles_length(reply.data());
                         ++i)
                     shape_region += QRegion(rects[ i ].x, rects[ i ].y,
                                             rects[ i ].width, rects[ i ].height);
                 // make sure the shape is sane (X is async, maybe even XShape is broken)
                 shape_region &= QRegion(0, 0, width(), height());
             } else
                 shape_region = QRegion();
         } else
             shape_region = QRegion(0, 0, width(), height());
         shape_valid = true;
     }
     return shape_region;
 }
 
 QRegion Scene::Window::clientShape() const
 {
     if (AbstractClient *c = dynamic_cast< AbstractClient * > (toplevel)) {
         if (c->isShade())
             return QRegion();
     }
 
     // TODO: cache
     const QRegion r = shape() & QRect(toplevel->clientPos(), toplevel->clientSize());
     return r.isEmpty() ? QRegion() : r;
 }
 
 bool Scene::Window::isVisible() const
 {
     if (toplevel->isDeleted())
         return false;
     if (!toplevel->isOnCurrentDesktop())
         return false;
     if (!toplevel->isOnCurrentActivity())
         return false;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel))
         return c->isShown(true);
     return true; // Unmanaged is always visible
 }
 
 bool Scene::Window::isOpaque() const
 {
     return toplevel->opacity() == 1.0 && !toplevel->hasAlpha();
 }
 
 bool Scene::Window::isPaintingEnabled() const
 {
     return !disable_painting;
 }
 
 void Scene::Window::resetPaintingEnabled()
 {
     disable_painting = 0;
     if (toplevel->isDeleted())
         disable_painting |= PAINT_DISABLED_BY_DELETE;
     if (static_cast<EffectsHandlerImpl*>(effects)->isDesktopRendering()) {
         if (!toplevel->isOnDesktop(static_cast<EffectsHandlerImpl*>(effects)->currentRenderedDesktop())) {
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
         }
     } else {
         if (!toplevel->isOnCurrentDesktop())
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
     }
     if (!toplevel->isOnCurrentActivity())
         disable_painting |= PAINT_DISABLED_BY_ACTIVITY;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel)) {
         if (c->isMinimized())
             disable_painting |= PAINT_DISABLED_BY_MINIMIZE;
         if (c->isHiddenInternal()) {
             disable_painting |= PAINT_DISABLED;
         }
     }
 }
 
 void Scene::Window::enablePainting(int reason)
 {
     disable_painting &= ~reason;
 }
 
 void Scene::Window::disablePainting(int reason)
 {
     disable_painting |= reason;
 }
 
 WindowQuadList Scene::Window::buildQuads(bool force) const
 {
     if (cached_quad_list != nullptr && !force)
         return *cached_quad_list;
     WindowQuadList ret;
 
     const qreal scale = toplevel->bufferScale();
 
     if (toplevel->clientPos() == QPoint(0, 0) && toplevel->clientSize() == toplevel->decorationRect().size())
         ret = makeQuads(WindowQuadContents, shape(), QPoint(0,0), scale);  // has no decoration
     else {
         AbstractClient *client = dynamic_cast<AbstractClient*>(toplevel);
         QRegion contents = clientShape();
         QRegion center = toplevel->transparentRect();
         QRegion decoration = (client ? QRegion(client->decorationRect()) : shape()) - center;
         qreal decorationScale = 1.0;
         ret = makeQuads(WindowQuadContents, contents, toplevel->clientContentPos(), scale);
 
         QRect rects[4];
         bool isShadedClient = false;
 
         if (client) {
             client->layoutDecorationRects(rects[0], rects[1], rects[2], rects[3]);
             decorationScale = client->screenScale();
             isShadedClient = client->isShade() || center.isEmpty();
         }
 
         if (isShadedClient) {
             const QRect bounding = rects[0] | rects[1] | rects[2] | rects[3];
             ret += makeDecorationQuads(rects, bounding, decorationScale);
         } else {
             ret += makeDecorationQuads(rects, decoration, decorationScale);
         }
 
     }
     if (m_shadow && toplevel->wantsShadowToBeRendered()) {
         ret << m_shadow->shadowQuads();
     }
     effects->buildQuads(toplevel->effectWindow(), ret);
     cached_quad_list.reset(new WindowQuadList(ret));
     return ret;
 }
 
 WindowQuadList Scene::Window::makeDecorationQuads(const QRect *rects, const QRegion &region, qreal textureScale) const
 {
     WindowQuadList list;
 
     const QPoint offsets[4] = {
         QPoint(-rects[0].x() + rects[1].height() + rects[3].height() + 2, -rects[0].y()),                    // Left
         QPoint(-rects[1].x(), -rects[1].y()),                                                                // Top
         QPoint(-rects[2].x() + rects[1].height() + rects[3].height() + rects[0].width() + 3, -rects[2].y()), // Right
         QPoint(-rects[3].x(), -rects[3].y() + rects[1].height() + 1)                                         // Bottom
     };
 
     const Qt::Orientation orientations[4] = {
         Qt::Vertical,   // Left
         Qt::Horizontal, // Top
         Qt::Vertical,   // Right
         Qt::Horizontal, // Bottom
     };
 
     for (int i = 0; i < 4; i++) {
         const QRegion intersectedRegion = (region & rects[i]);
         for (const QRect &r : intersectedRegion) {
             if (!r.isValid())
                 continue;
 
             const bool swap = orientations[i] == Qt::Vertical;
 
             const int x0 = r.x();
             const int y0 = r.y();
             const int x1 = r.x() + r.width();
             const int y1 = r.y() + r.height();
 
             const int u0 = (x0 + offsets[i].x()) * textureScale;
             const int v0 = (y0 + offsets[i].y()) * textureScale;
             const int u1 = (x1 + offsets[i].x()) * textureScale;
             const int v1 = (y1 + offsets[i].y()) * textureScale;
 
             WindowQuad quad(WindowQuadDecoration);
             quad.setUVAxisSwapped(swap);
 
             if (swap) {
                 quad[0] = WindowVertex(x0, y0, v0, u0); // Top-left
                 quad[1] = WindowVertex(x1, y0, v0, u1); // Top-right
                 quad[2] = WindowVertex(x1, y1, v1, u1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, v1, u0); // Bottom-left
             } else {
                 quad[0] = WindowVertex(x0, y0, u0, v0); // Top-left
                 quad[1] = WindowVertex(x1, y0, u1, v0); // Top-right
                 quad[2] = WindowVertex(x1, y1, u1, v1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, u0, v1); // Bottom-left
             }
 
             list.append(quad);
         }
     }
 
     return list;
 }
 
 void Scene::Window::invalidateQuadsCache()
 {
     cached_quad_list.reset();
 }
 
 WindowQuadList Scene::Window::makeQuads(WindowQuadType type, const QRegion& reg, const QPoint &textureOffset, qreal scale) const
 {
     WindowQuadList ret;
     ret.reserve(reg.rectCount());
     for (const QRect &r : reg) {
         WindowQuad quad(type);
         // TODO asi mam spatne pravy dolni roh - bud tady, nebo v jinych castech
         quad[ 0 ] = WindowVertex(QPointF(r.x(), r.y()),
                                  QPointF(r.x() + textureOffset.x(), r.y() + textureOffset.y()) * scale);
         quad[ 1 ] = WindowVertex(QPointF(r.x() + r.width(), r.y()),
                                  QPointF(r.x() + r.width() + textureOffset.x(), r.y() + textureOffset.y()) * scale);
         quad[ 2 ] = WindowVertex(QPointF(r.x() + r.width(), r.y() + r.height()),
                                  QPointF(r.x() + r.width() + textureOffset.x(), r.y() + r.height() + textureOffset.y()) * scale);
         quad[ 3 ] = WindowVertex(QPointF(r.x(), r.y() + r.height()),
                                  QPointF(r.x() + textureOffset.x(), r.y() + r.height() + textureOffset.y()) * scale);
 
         ret.append(quad);
     }
     return ret;
 }
 
 void Scene::Window::updateShadow(Shadow* shadow)
 {
     if (m_shadow == shadow) {
         return;
     }
     delete m_shadow;
     m_shadow = shadow;
 }
 
 //****************************************
 // WindowPixmap
 //****************************************
 WindowPixmap::WindowPixmap(Scene::Window *window)
     : m_window(window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
 {
 }
 
 WindowPixmap::WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
     : m_window(parent->m_window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
     , m_parent(parent)
     , m_subSurface(subSurface)
 {
 }
 
 WindowPixmap::~WindowPixmap()
 {
     if (m_pixmap != XCB_WINDOW_NONE) {
         xcb_free_pixmap(connection(), m_pixmap);
     }
     if (m_buffer) {
         using namespace KWayland::Server;
         QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         m_buffer->unref();
     }
 }
 
 void WindowPixmap::create()
 {
     if (isValid() || toplevel()->isDeleted()) {
         return;
     }
     // always update from Buffer on Wayland, don't try using XPixmap
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         // use Buffer
         updateBuffer();
         if ((m_buffer || !m_fbo.isNull()) && m_subSurface.isNull()) {
             m_window->unreferencePreviousPixmap();
         }
         return;
     }
     XServerGrabber grabber;
     xcb_pixmap_t pix = xcb_generate_id(connection());
     xcb_void_cookie_t namePixmapCookie = xcb_composite_name_window_pixmap_checked(connection(), toplevel()->frameId(), pix);
     Xcb::WindowAttributes windowAttributes(toplevel()->frameId());
     Xcb::WindowGeometry windowGeometry(toplevel()->frameId());
     if (xcb_generic_error_t *error = xcb_request_check(connection(), namePixmapCookie)) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << error->error_code;
         free(error);
         return;
     }
     // check that the received pixmap is valid and actually matches what we
     // know about the window (i.e. size)
     if (!windowAttributes || windowAttributes->map_state != XCB_MAP_STATE_VIEWABLE) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     if (!windowGeometry ||
         windowGeometry->width != toplevel()->width() || windowGeometry->height != toplevel()->height()) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     m_pixmap = pix;
     m_pixmapSize = QSize(toplevel()->width(), toplevel()->height());
     m_contentsRect = QRect(toplevel()->clientPos(), toplevel()->clientSize());
     m_window->unreferencePreviousPixmap();
 }
 
 WindowPixmap *WindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
 {
     Q_UNUSED(subSurface)
     return nullptr;
 }
 
 bool WindowPixmap::isValid() const
 {
     if (!m_buffer.isNull() || !m_fbo.isNull() || !m_internalImage.isNull()) {
         return true;
     }
     return m_pixmap != XCB_PIXMAP_NONE;
 }
 
 void WindowPixmap::updateBuffer()
 {
     using namespace KWayland::Server;
     if (SurfaceInterface *s = surface()) {
         QVector<WindowPixmap*> oldTree = m_children;
         QVector<WindowPixmap*> children;
         using namespace KWayland::Server;
         const auto subSurfaces = s->childSubSurfaces();
         for (const auto &subSurface : subSurfaces) {
             if (subSurface.isNull()) {
                 continue;
             }
             auto it = std::find_if(oldTree.begin(), oldTree.end(), [subSurface] (WindowPixmap *p) { return p->m_subSurface == subSurface; });
             if (it != oldTree.end()) {
                 children << *it;
                 (*it)->updateBuffer();
                 oldTree.erase(it);
             } else {
                 WindowPixmap *p = createChild(subSurface);
                 if (p) {
                     p->create();
                     children << p;
                 }
             }
         }
         setChildren(children);
         qDeleteAll(oldTree);
         if (auto b = s->buffer()) {
             if (b == m_buffer) {
                 // no change
                 return;
             }
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
             }
             m_buffer = b;
             m_buffer->ref();
             QObject::connect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         } else if (m_subSurface) {
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
                 m_buffer.clear();
             }
         }
     } else if (toplevel()->internalFramebufferObject()) {
         m_fbo = toplevel()->internalFramebufferObject();
     } else if (!toplevel()->internalImageObject().isNull()) {
         m_internalImage = toplevel()->internalImageObject();
     } else {
         if (m_buffer) {
             QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
             m_buffer->unref();
             m_buffer.clear();
         }
     }
 }
 
 KWayland::Server::SurfaceInterface *WindowPixmap::surface() const
 {
     if (!m_subSurface.isNull()) {
         return m_subSurface->surface().data();
     } else {
         return toplevel()->surface();
     }
 }
 
 //****************************************
 // Scene::EffectFrame
 //****************************************
 Scene::EffectFrame::EffectFrame(EffectFrameImpl* frame)
     : m_effectFrame(frame)
 {
 }
 
 Scene::EffectFrame::~EffectFrame()
 {
 }
 
 SceneFactory::SceneFactory(QObject *parent)
     : QObject(parent)
 {
 }
 
 SceneFactory::~SceneFactory()
 {
 }
 
 } // namespace
diff --git a/scene.h b/scene.h
index 561901fca..d547d1228 100644
--- a/scene.h
+++ b/scene.h
@@ -1,698 +1,697 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@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_SCENE_H
 #define KWIN_SCENE_H
 
 #include "toplevel.h"
 #include "utils.h"
 #include "kwineffects.h"
 
 #include <QElapsedTimer>
 #include <QMatrix4x4>
 
 class QOpenGLFramebufferObject;
 
 namespace KWayland
 {
 namespace Server
 {
 class BufferInterface;
 class SubSurfaceInterface;
 }
 }
 
 namespace KWin
 {
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class Renderer;
 }
 
 class AbstractThumbnailItem;
 class Deleted;
 class EffectFrameImpl;
 class EffectWindowImpl;
 class OverlayWindow;
 class Shadow;
 class WindowPixmap;
 
 // The base class for compositing backends.
 class KWIN_EXPORT Scene : public QObject
 {
     Q_OBJECT
 public:
     explicit Scene(QObject *parent = nullptr);
     ~Scene() override = 0;
     class EffectFrame;
     class Window;
 
     // Returns true if the ctor failed to properly initialize.
     virtual bool initFailed() const = 0;
     virtual CompositingType compositingType() const = 0;
 
     virtual bool hasPendingFlush() const { return false; }
 
     // Repaints the given screen areas, windows provides the stacking order.
     // The entry point for the main part of the painting pass.
     // returns the time since the last vblank signal - if there's one
     // ie. "what of this frame is lost to painting"
     virtual qint64 paint(QRegion damage, ToplevelList windows) = 0;
 
     /**
      * Adds the Toplevel to the Scene.
      *
      * If the toplevel gets deleted, then the scene will try automatically
      * to re-bind an underlying scene window to the corresponding Deleted.
      *
      * @param toplevel The window to be added.
      * @note You can add a toplevel to scene only once.
      */
     void addToplevel(Toplevel *toplevel);
 
     /**
      * Removes the Toplevel from the Scene.
      *
      * @param toplevel The window to be removed.
      * @note You can remove a toplevel from the scene only once.
      */
     void removeToplevel(Toplevel *toplevel);
 
     /**
      * @brief Creates the Scene backend of an EffectFrame.
      *
      * @param frame The EffectFrame this Scene::EffectFrame belongs to.
      */
     virtual Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame) = 0;
     /**
      * @brief Creates the Scene specific Shadow subclass.
      *
      * An implementing class has to create a proper instance. It is not allowed to
      * return @c null.
      *
      * @param toplevel The Toplevel for which the Shadow needs to be created.
      */
     virtual Shadow *createShadow(Toplevel *toplevel) = 0;
     /**
      * Method invoked when the screen geometry is changed.
      * Reimplementing classes should also invoke the parent method
      * as it takes care of resizing the overlay window.
      * @param size The new screen geometry size
      */
     virtual void screenGeometryChanged(const QSize &size);
     // Flags controlling how painting is done.
     enum {
         // Window (or at least part of it) will be painted opaque.
         PAINT_WINDOW_OPAQUE         = 1 << 0,
         // Window (or at least part of it) will be painted translucent.
         PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
         // Window will be painted with transformed geometry.
         PAINT_WINDOW_TRANSFORMED    = 1 << 2,
         // Paint only a region of the screen (can be optimized, cannot
         // be used together with TRANSFORMED flags).
         PAINT_SCREEN_REGION         = 1 << 3,
         // Whole screen will be painted with transformed geometry.
         PAINT_SCREEN_TRANSFORMED    = 1 << 4,
         // At least one window will be painted with transformed geometry.
         PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
         // Clear whole background as the very first step, without optimizing it
         PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
         // PAINT_DECORATION_ONLY = 1 << 7 has been removed
         // Window will be painted with a lanczos filter.
         PAINT_WINDOW_LANCZOS = 1 << 8
         // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS = 1 << 9 has been removed
     };
     // types of filtering available
     enum ImageFilterType { ImageFilterFast, ImageFilterGood };
     // there's nothing to paint (adjust time_diff later)
     virtual void idle();
     virtual bool blocksForRetrace() const;
-    virtual bool syncsToVBlank() const;
     virtual OverlayWindow* overlayWindow() const = 0;
 
     virtual bool makeOpenGLContextCurrent();
     virtual void doneOpenGLContextCurrent();
 
     virtual QMatrix4x4 screenProjectionMatrix() const;
 
     /**
      * Whether the Scene uses an X11 overlay window to perform compositing.
      */
     virtual bool usesOverlayWindow() const = 0;
 
     virtual void triggerFence();
 
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *) = 0;
 
     /**
      * Whether the Scene is able to drive animations.
      * This is used as a hint to the effects system which effects can be supported.
      * If the Scene performs software rendering it is supposed to return @c false,
      * if rendering is hardware accelerated it should return @c true.
      */
     virtual bool animationsSupported() const = 0;
 
     /**
      * The render buffer used by an XRender based compositor scene.
      * Default implementation returns XCB_RENDER_PICTURE_NONE
      */
     virtual xcb_render_picture_t xrenderBufferPicture() const;
 
     /**
      * The QPainter used by a QPainter based compositor scene.
      * Default implementation returns @c nullptr;
      */
     virtual QPainter *scenePainter() const;
 
     /**
      * The render buffer used by a QPainter based compositor.
      * Default implementation returns @c nullptr.
      */
     virtual QImage *qpainterRenderBuffer() const;
 
     /**
      * The backend specific extensions (e.g. EGL/GLX extensions).
      *
      * Not the OpenGL (ES) extension!
      *
      * Default implementation returns empty list
      */
     virtual QVector<QByteArray> openGLPlatformInterfaceExtensions() const;
 
 Q_SIGNALS:
     void frameRendered();
     void resetCompositing();
 
 public Q_SLOTS:
     // shape/size of a window changed
     void windowGeometryShapeChanged(KWin::Toplevel* c);
     // a window has been closed
     void windowClosed(KWin::Toplevel* c, KWin::Deleted* deleted);
 protected:
     virtual Window *createWindow(Toplevel *toplevel) = 0;
     void createStackingOrder(ToplevelList toplevels);
     void clearStackingOrder();
     // shared implementation, starts painting the screen
     void paintScreen(int *mask, const QRegion &damage, const QRegion &repaint,
                      QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection = QMatrix4x4(), const QRect &outputGeometry = QRect());
     // Render cursor texture in case hardware cursor is disabled/non-applicable
     virtual void paintCursor() = 0;
     friend class EffectsHandlerImpl;
     // called after all effects had their paintScreen() called
     void finalPaintScreen(int mask, QRegion region, ScreenPaintData& data);
     // shared implementation of painting the screen in the generic
     // (unoptimized) way
     virtual void paintGenericScreen(int mask, ScreenPaintData data);
     // shared implementation of painting the screen in an optimized way
     virtual void paintSimpleScreen(int mask, QRegion region);
     // paint the background (not the desktop background - the whole background)
     virtual void paintBackground(QRegion region) = 0;
     // called after all effects had their paintWindow() called
     void finalPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data);
     // shared implementation, starts painting the window
     virtual void paintWindow(Window* w, int mask, QRegion region, WindowQuadList quads);
     // called after all effects had their drawWindow() called
     virtual void finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data);
     // let the scene decide whether it's better to paint more of the screen, eg. in order to allow a buffer swap
     // the default is NOOP
     virtual void extendPaintRegion(QRegion &region, bool opaqueFullscreen);
     virtual void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data);
 
     virtual void paintEffectQuickView(EffectQuickView *w) = 0;
 
     // compute time since the last repaint
     void updateTimeDiff();
     // saved data for 2nd pass of optimized screen painting
     struct Phase2Data {
         Window *window = nullptr;
         QRegion region;
         QRegion clip;
         int mask = 0;
         WindowQuadList quads;
     };
     // The region which actually has been painted by paintScreen() and should be
     // copied from the buffer to the screen. I.e. the region returned from Scene::paintScreen().
     // Since prePaintWindow() can extend areas to paint, these changes would have to propagate
     // up all the way from paintSimpleScreen() up to paintScreen(), so save them here rather
     // than propagate them up in arguments.
     QRegion painted_region;
     // Additional damage that needs to be repaired to bring a reused back buffer up to date
     QRegion repaint_region;
     // The dirty region before it was unioned with repaint_region
     QRegion damaged_region;
     // time since last repaint
     int time_diff;
     QElapsedTimer last_time;
 private:
     void paintWindowThumbnails(Scene::Window *w, QRegion region, qreal opacity, qreal brightness, qreal saturation);
     void paintDesktopThumbnails(Scene::Window *w);
     QHash< Toplevel*, Window* > m_windows;
     // windows in their stacking order
     QVector< Window* > stacking_order;
 };
 
 /**
  * Factory class to create a Scene. Needs to be implemented by the plugins.
  */
 class KWIN_EXPORT SceneFactory : public QObject
 {
     Q_OBJECT
 public:
     ~SceneFactory() override;
 
     /**
      * @returns The created Scene, may be @c nullptr.
      */
     virtual Scene *create(QObject *parent = nullptr) const = 0;
 
 protected:
     explicit SceneFactory(QObject *parent);
 };
 
 // The base class for windows representations in composite backends
 class Scene::Window
 {
 public:
     Window(Toplevel* c);
     virtual ~Window();
     // perform the actual painting of the window
     virtual void performPaint(int mask, QRegion region, WindowPaintData data) = 0;
     // do any cleanup needed when the window's composite pixmap is discarded
     void pixmapDiscarded();
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     QRect geometry() const;
     QPoint pos() const;
     QSize size() const;
     QRect rect() const;
     // access to the internal window class
     // TODO eventually get rid of this
     Toplevel* window() const;
     // should the window be painted
     bool isPaintingEnabled() const;
     void resetPaintingEnabled();
     // Flags explaining why painting should be disabled
     enum {
         // Window will not be painted
         PAINT_DISABLED                 = 1 << 0,
         // Window will not be painted because it is deleted
         PAINT_DISABLED_BY_DELETE       = 1 << 1,
         // Window will not be painted because of which desktop it's on
         PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
         // Window will not be painted because it is minimized
         PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
         // Window will not be painted because it's not on the current activity
         PAINT_DISABLED_BY_ACTIVITY     = 1 << 5
     };
     void enablePainting(int reason);
     void disablePainting(int reason);
     // is the window visible at all
     bool isVisible() const;
     // is the window fully opaque
     bool isOpaque() const;
     // shape of the window
     const QRegion &shape() const;
     QRegion clientShape() const;
     void discardShape();
     void updateToplevel(Toplevel* c);
     // creates initial quad list for the window
     virtual WindowQuadList buildQuads(bool force = false) const;
     void updateShadow(Shadow* shadow);
     const Shadow* shadow() const;
     Shadow* shadow();
     void referencePreviousPixmap();
     void unreferencePreviousPixmap();
     void invalidateQuadsCache();
 protected:
     WindowQuadList makeQuads(WindowQuadType type, const QRegion& reg, const QPoint &textureOffset = QPoint(0, 0), qreal textureScale = 1.0) const;
     WindowQuadList makeDecorationQuads(const QRect *rects, const QRegion &region, qreal textureScale = 1.0) const;
     /**
      * @brief Returns the WindowPixmap for this Window.
      *
      * If the WindowPixmap does not yet exist, this method will invoke createWindowPixmap.
      * If the WindowPixmap is not valid it tries to create it, in case this succeeds the WindowPixmap is
      * returned. In case it fails, the previous (and still valid) WindowPixmap is returned.
      *
      * @note This method can return @c NULL as there might neither be a valid previous nor current WindowPixmap
      * around.
      *
      * The WindowPixmap gets casted to the type passed in as a template parameter. That way this class does not
      * need to know the actual WindowPixmap subclass used by the concrete Scene implementations.
      *
      * @return The WindowPixmap casted to T* or @c NULL if there is no valid window pixmap.
      */
     template<typename T> T *windowPixmap();
     template<typename T> T *previousWindowPixmap();
     /**
      * @brief Factory method to create a WindowPixmap.
      *
      * The inheriting classes need to implement this method to create a new instance of their WindowPixmap subclass.
      * @note Do not use WindowPixmap::create on the created instance. The Scene will take care of that.
      */
     virtual WindowPixmap *createWindowPixmap() = 0;
     Toplevel* toplevel;
     ImageFilterType filter;
     Shadow *m_shadow;
 private:
     QScopedPointer<WindowPixmap> m_currentPixmap;
     QScopedPointer<WindowPixmap> m_previousPixmap;
     int m_referencePixmapCounter;
     int disable_painting;
     mutable QRegion shape_region;
     mutable bool shape_valid;
     mutable QScopedPointer<WindowQuadList> cached_quad_list;
     Q_DISABLE_COPY(Window)
 };
 
 /**
  * @brief Wrapper for a pixmap of the Scene::Window.
  *
  * This class encapsulates the functionality to get the pixmap for a window. When initialized the pixmap is not yet
  * mapped to the window and isValid will return @c false. The pixmap mapping to the window can be established
  * through @ref create. If it succeeds isValid will return @c true, otherwise it will keep in the non valid
  * state and it can be tried to create the pixmap mapping again (e.g. in the next frame).
  *
  * This class is not intended to be updated when the pixmap is no longer valid due to e.g. resizing the window.
  * Instead a new instance of this class should be instantiated. The idea behind this is that a valid pixmap does not
  * get destroyed, but can continue to be used. To indicate that a newer pixmap should in generally be around, one can
  * use markAsDiscarded.
  *
  * This class is intended to be inherited for the needs of the compositor backends which need further mapping from
  * the native pixmap to the respective rendering format.
  */
 class KWIN_EXPORT WindowPixmap
 {
 public:
     virtual ~WindowPixmap();
     /**
      * @brief Tries to create the mapping between the Window and the pixmap.
      *
      * In case this method succeeds in creating the pixmap for the window, isValid will return @c true otherwise
      * @c false.
      *
      * Inheriting classes should re-implement this method in case they need to add further functionality for mapping the
      * native pixmap to the rendering format.
      */
     virtual void create();
     /**
      * @return @c true if the pixmap has been created and is valid, @c false otherwise
      */
     virtual bool isValid() const;
     /**
      * @return The native X11 pixmap handle
      */
     xcb_pixmap_t pixmap() const;
     /**
      * @return The Wayland BufferInterface for this WindowPixmap.
      */
     QPointer<KWayland::Server::BufferInterface> buffer() const;
     const QSharedPointer<QOpenGLFramebufferObject> &fbo() const;
     QImage internalImage() const;
     /**
      * @brief Whether this WindowPixmap is considered as discarded. This means the window has changed in a way that a new
      * WindowPixmap should have been created already.
      *
      * @return @c true if this WindowPixmap is considered as discarded, @c false otherwise.
      * @see markAsDiscarded
      */
     bool isDiscarded() const;
     /**
      * @brief Marks this WindowPixmap as discarded. From now on isDiscarded will return @c true. This method should
      * only be used by the Window when it changes in a way that a new pixmap is required.
      *
      * @see isDiscarded
      */
     void markAsDiscarded();
     /**
      * The size of the pixmap.
      */
     const QSize &size() const;
     /**
      * The geometry of the Client's content inside the pixmap. In case of a decorated Client the
      * pixmap also contains the decoration which is not rendered into this pixmap, though. This
      * contentsRect tells where inside the complete pixmap the real content is.
      */
     const QRect &contentsRect() const;
     /**
      * @brief Returns the Toplevel this WindowPixmap belongs to.
      * Note: the Toplevel can change over the lifetime of the WindowPixmap in case the Toplevel is copied to Deleted.
      */
     Toplevel *toplevel() const;
 
     /**
      * @returns the parent WindowPixmap in the sub-surface tree
      */
     WindowPixmap *parent() const {
         return m_parent;
     }
 
     /**
      * @returns the current sub-surface tree
      */
     QVector<WindowPixmap*> children() const {
         return m_children;
     }
 
     /**
      * @returns the subsurface this WindowPixmap is for if it is not for a root window
      */
     QPointer<KWayland::Server::SubSurfaceInterface> subSurface() const {
         return m_subSurface;
     }
 
     /**
      * @returns the surface this WindowPixmap references, might be @c null.
      */
     KWayland::Server::SurfaceInterface *surface() const;
 
 protected:
     explicit WindowPixmap(Scene::Window *window);
     explicit WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
     virtual WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface);
     /**
      * @return The Window this WindowPixmap belongs to
      */
     Scene::Window *window();
 
     /**
      * Should be called by the implementing subclasses when the Wayland Buffer changed and needs
      * updating.
      */
     virtual void updateBuffer();
 
     /**
      * Sets the sub-surface tree to @p children.
      */
     void setChildren(const QVector<WindowPixmap*> &children) {
         m_children = children;
     }
 
 private:
     Scene::Window *m_window;
     xcb_pixmap_t m_pixmap;
     QSize m_pixmapSize;
     bool m_discarded;
     QRect m_contentsRect;
     QPointer<KWayland::Server::BufferInterface> m_buffer;
     QSharedPointer<QOpenGLFramebufferObject> m_fbo;
     QImage m_internalImage;
     WindowPixmap *m_parent = nullptr;
     QVector<WindowPixmap*> m_children;
     QPointer<KWayland::Server::SubSurfaceInterface> m_subSurface;
 };
 
 class Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame);
     virtual ~EffectFrame();
     virtual void render(QRegion region, double opacity, double frameOpacity) = 0;
     virtual void free() = 0;
     virtual void freeIconFrame() = 0;
     virtual void freeTextFrame() = 0;
     virtual void freeSelection() = 0;
     virtual void crossFadeIcon() = 0;
     virtual void crossFadeText() = 0;
 
 protected:
     EffectFrameImpl* m_effectFrame;
 };
 
 inline
 int Scene::Window::x() const
 {
     return toplevel->x();
 }
 
 inline
 int Scene::Window::y() const
 {
     return toplevel->y();
 }
 
 inline
 int Scene::Window::width() const
 {
     return toplevel->width();
 }
 
 inline
 int Scene::Window::height() const
 {
     return toplevel->height();
 }
 
 inline
 QRect Scene::Window::geometry() const
 {
     return toplevel->frameGeometry();
 }
 
 inline
 QSize Scene::Window::size() const
 {
     return toplevel->size();
 }
 
 inline
 QPoint Scene::Window::pos() const
 {
     return toplevel->pos();
 }
 
 inline
 QRect Scene::Window::rect() const
 {
     return toplevel->rect();
 }
 
 inline
 Toplevel* Scene::Window::window() const
 {
     return toplevel;
 }
 
 inline
 void Scene::Window::updateToplevel(Toplevel* c)
 {
     toplevel = c;
 }
 
 inline
 const Shadow* Scene::Window::shadow() const
 {
     return m_shadow;
 }
 
 inline
 Shadow* Scene::Window::shadow()
 {
     return m_shadow;
 }
 
 inline
 QPointer<KWayland::Server::BufferInterface> WindowPixmap::buffer() const
 {
     return m_buffer;
 }
 
 inline
 const QSharedPointer<QOpenGLFramebufferObject> &WindowPixmap::fbo() const
 {
     return m_fbo;
 }
 
 inline
 QImage WindowPixmap::internalImage() const
 {
     return m_internalImage;
 }
 
 template <typename T>
 inline
 T* Scene::Window::windowPixmap()
 {
     if (m_currentPixmap.isNull()) {
         m_currentPixmap.reset(createWindowPixmap());
     }
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     }
     m_currentPixmap->create();
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     } else {
         return static_cast<T*>(m_previousPixmap.data());
     }
 }
 
 template <typename T>
 inline
 T* Scene::Window::previousWindowPixmap()
 {
     return static_cast<T*>(m_previousPixmap.data());
 }
 
 inline
 Toplevel* WindowPixmap::toplevel() const
 {
     return m_window->window();
 }
 
 inline
 xcb_pixmap_t WindowPixmap::pixmap() const
 {
     return m_pixmap;
 }
 
 inline
 bool WindowPixmap::isDiscarded() const
 {
     return m_discarded;
 }
 
 inline
 void WindowPixmap::markAsDiscarded()
 {
     m_discarded = true;
     m_window->referencePreviousPixmap();
 }
 
 inline
 const QRect &WindowPixmap::contentsRect() const
 {
     return m_contentsRect;
 }
 
 inline
 const QSize &WindowPixmap::size() const
 {
     return m_pixmapSize;
 }
 
 } // namespace
 
 Q_DECLARE_INTERFACE(KWin::SceneFactory, "org.kde.kwin.Scene")
 
 #endif