diff --git a/shell_client.cpp b/shell_client.cpp
index 0b0e4cbce..58f050687 100644
--- a/shell_client.cpp
+++ b/shell_client.cpp
@@ -1,1995 +1,1980 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 David Edmundson <davidedmundson@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 "shell_client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "placement.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "virtualdesktops.h"
 #include "screens.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/decoratedclient.h"
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecoratedClient>
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/clientconnection.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/shell_interface.h>
 #include <KWayland/Server/surface_interface.h>
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/plasmashell_interface.h>
 #include <KWayland/Server/shadow_interface.h>
 #include <KWayland/Server/server_decoration_interface.h>
 #include <KWayland/Server/qtsurfaceextension_interface.h>
 #include <KWayland/Server/plasmawindowmanagement_interface.h>
 #include <KWayland/Server/appmenu_interface.h>
 #include <KWayland/Server/server_decoration_palette_interface.h>
 #include <KWayland/Server/xdgdecoration_interface.h>
 
 #include <KDesktopFile>
 
 #include <QFileInfo>
 #include <QOpenGLFramebufferObject>
 #include <QWindow>
 
 #include <sys/types.h>
 #include <unistd.h>
 #include <signal.h>
 
 Q_DECLARE_METATYPE(NET::WindowType)
 
 using namespace KWayland::Server;
 
 static const QByteArray s_skipClosePropertyName = QByteArrayLiteral("KWIN_SKIP_CLOSE_ANIMATION");
 
 namespace KWin
 {
 
 ShellClient::ShellClient(ShellSurfaceInterface *surface)
     : AbstractClient()
     , m_shellSurface(surface)
     , m_xdgShellSurface(nullptr)
     , m_xdgShellPopup(nullptr)
     , m_internal(surface->client() == waylandServer()->internalConnection())
 {
     setSurface(surface->surface());
     init();
 }
 
 ShellClient::ShellClient(XdgShellSurfaceInterface *surface)
     : AbstractClient()
     , m_shellSurface(nullptr)
     , m_xdgShellSurface(surface)
     , m_xdgShellPopup(nullptr)
     , m_internal(surface->client() == waylandServer()->internalConnection())
 {
     setSurface(surface->surface());
     init();
 }
 
 ShellClient::ShellClient(XdgShellPopupInterface *surface)
     : AbstractClient()
     , m_shellSurface(nullptr)
     , m_xdgShellSurface(nullptr)
     , m_xdgShellPopup(surface)
     , m_internal(surface->client() == waylandServer()->internalConnection())
 {
     setSurface(surface->surface());
     init();
 }
 
 ShellClient::~ShellClient() = default;
 
 template <class T>
 void ShellClient::initSurface(T *shellSurface)
 {
     m_caption = shellSurface->title().simplified();
     // delay till end of init
     QTimer::singleShot(0, this, &ShellClient::updateCaption);
     connect(shellSurface, &T::destroyed, this, &ShellClient::destroyClient);
     connect(shellSurface, &T::titleChanged, this,
         [this] (const QString &s) {
             const auto oldSuffix = m_captionSuffix;
             m_caption = s.simplified();
             updateCaption();
             if (m_captionSuffix == oldSuffix) {
                 // don't emit caption change twice
                 // it already got emitted by the changing suffix
                 emit captionChanged();
             }
         }
     );
     connect(shellSurface, &T::moveRequested, this,
         [this] {
             // TODO: check the seat and serial
             performMouseCommand(Options::MouseMove, Cursor::pos());
         }
     );
 
     // determine the resource name, this is inspired from ICCCM 4.1.2.5
     // the binary name of the invoked client
     QFileInfo info{shellSurface->client()->executablePath()};
     QByteArray resourceName;
     if (info.exists()) {
         resourceName = info.fileName().toUtf8();
     }
     setResourceClass(resourceName, shellSurface->windowClass());
     connect(shellSurface, &T::windowClassChanged, this,
         [this, resourceName] (const QByteArray &windowClass) {
             setResourceClass(resourceName, windowClass);
             if (!m_internal) {
                 setupWindowRules(true);
                 applyWindowRules();
             }
             setDesktopFileName(windowClass);
         }
     );
     connect(shellSurface, &T::resizeRequested, this,
         [this] (SeatInterface *seat, quint32 serial, Qt::Edges edges) {
             // TODO: check the seat and serial
             Q_UNUSED(seat)
             Q_UNUSED(serial)
             if (!isResizable() || isShade()) {
                 return;
             }
             if (isMoveResize()) {
                 finishMoveResize(false);
             }
             setMoveResizePointerButtonDown(true);
             setMoveOffset(Cursor::pos() - pos());  // map from global
             setInvertedMoveOffset(rect().bottomRight() - moveOffset());
             setUnrestrictedMoveResize(false);
             auto toPosition = [edges] {
                 Position pos = PositionCenter;
                 if (edges.testFlag(Qt::TopEdge)) {
                     pos = PositionTop;
                 } else if (edges.testFlag(Qt::BottomEdge)) {
                     pos = PositionBottom;
                 }
                 if (edges.testFlag(Qt::LeftEdge)) {
                     pos = Position(pos | PositionLeft);
                 } else if (edges.testFlag(Qt::RightEdge)) {
                     pos = Position(pos | PositionRight);
                 }
                 return pos;
             };
             setMoveResizePointerMode(toPosition());
             if (!startMoveResize())
                 setMoveResizePointerButtonDown(false);
             updateCursor();
         }
     );
     connect(shellSurface, &T::maximizedChanged, this,
         [this] (bool maximized) {
             if (m_shellSurface && isFullScreen()) {
                 // ignore for wl_shell - there it is mutual exclusive and messes with the geometry
                 return;
             }
             maximize(maximized ? MaximizeFull : MaximizeRestore);
         }
     );
     // TODO: consider output!
     connect(shellSurface, &T::fullscreenChanged, this, &ShellClient::clientFullScreenChanged);
 
     connect(shellSurface, &T::transientForChanged, this, &ShellClient::setTransient);
 
     connect(this, &ShellClient::geometryChanged, this, &ShellClient::updateClientOutputs);
     connect(screens(), &Screens::changed, this, &ShellClient::updateClientOutputs);
 
     if (!m_internal) {
         setupWindowRules(false);
     }
     setDesktopFileName(rules()->checkDesktopFile(shellSurface->windowClass(), true).toUtf8());
 }
 
 void ShellClient::init()
 {
     connect(this, &ShellClient::desktopFileNameChanged, this, &ShellClient::updateIcon);
     findInternalWindow();
     createWindowId();
     setupCompositing();
     updateIcon();
     SurfaceInterface *s = surface();
     Q_ASSERT(s);
     if (s->buffer()) {
         setReadyForPainting();
         if (shouldExposeToWindowManagement()) {
             setupWindowManagementInterface();
         }
         m_unmapped = false;
         m_clientSize = s->size();
     } else {
         ready_for_painting = false;
     }
     if (m_internalWindow) {
         updateInternalWindowGeometry();
         updateDecoration(true);
     } else {
         doSetGeometry(QRect(QPoint(0, 0), m_clientSize));
     }
     if (waylandServer()->inputMethodConnection() == s->client()) {
         m_windowType = NET::OnScreenDisplay;
     }
 
     connect(s, &SurfaceInterface::sizeChanged, this,
         [this] {
             m_clientSize = surface()->size();
             doSetGeometry(QRect(geom.topLeft(), m_clientSize + QSize(borderLeft() + borderRight(), borderTop() + borderBottom())));
         }
     );
     connect(s, &SurfaceInterface::unmapped, this, &ShellClient::unmap);
     connect(s, &SurfaceInterface::unbound, this, &ShellClient::destroyClient);
     connect(s, &SurfaceInterface::destroyed, this, &ShellClient::destroyClient);
     if (m_shellSurface) {
         initSurface(m_shellSurface);
         auto setPopup = [this] {
             // TODO: verify grab serial
             m_hasPopupGrab = m_shellSurface->isPopup();
         };
         connect(m_shellSurface, &ShellSurfaceInterface::popupChanged, this, setPopup);
         setPopup();
     } else if (m_xdgShellSurface) {
         initSurface(m_xdgShellSurface);
 
         auto global = static_cast<XdgShellInterface *>(m_xdgShellSurface->global());
         connect(global, &XdgShellInterface::pingDelayed,
             this, [this](qint32 serial) {
                 auto it = m_pingSerials.find(serial);
                 if (it != m_pingSerials.end()) {
                     qCDebug(KWIN_CORE) << "First ping timeout:" << caption();
                     setUnresponsive(true);
                 }
             });
 
         connect(m_xdgShellSurface, &XdgShellSurfaceInterface::configureAcknowledged, this, [this](int serial) {
            m_lastAckedConfigureRequest = serial;
         });
 
         connect(global, &XdgShellInterface::pingTimeout,
             this, [this](qint32 serial) {
                 auto it = m_pingSerials.find(serial);
                 if (it != m_pingSerials.end()) {
                     if (it.value() == PingReason::CloseWindow) {
                         qCDebug(KWIN_CORE) << "Final ping timeout on a close attempt, asking to kill:" << caption();
 
                         //for internal windows, killing the window will delete this
                         QPointer<QObject> guard(this);
                         killWindow();
                         if (!guard) {
                             return;
                         }
                     }
                     m_pingSerials.erase(it);
                 }
             });
 
         connect(global, &XdgShellInterface::pongReceived,
             this, [this](qint32 serial){
                 auto it = m_pingSerials.find(serial);
                 if (it != m_pingSerials.end()) {
                     setUnresponsive(false);
                     m_pingSerials.erase(it);
                 }
             });
 
         connect(m_xdgShellSurface, &XdgShellSurfaceInterface::windowMenuRequested, this,
             [this] (SeatInterface *seat, quint32 serial, const QPoint &surfacePos) {
                 // TODO: check serial on seat
                 Q_UNUSED(seat)
                 Q_UNUSED(serial)
                 performMouseCommand(Options::MouseOperationsMenu, pos() + surfacePos);
             }
         );
         connect(m_xdgShellSurface, &XdgShellSurfaceInterface::minimizeRequested, this,
             [this] {
                 performMouseCommand(Options::MouseMinimize, Cursor::pos());
             }
         );
         auto configure = [this] {
             if (m_closing) {
                 return;
             }
             if (m_requestGeometryBlockCounter != 0 || areGeometryUpdatesBlocked()) {
                 return;
             }
             m_xdgShellSurface->configure(xdgSurfaceStates(), m_requestedClientSize);
         };
         configure();
         connect(this, &AbstractClient::activeChanged, this, configure);
         connect(this, &AbstractClient::clientStartUserMovedResized, this, configure);
         connect(this, &AbstractClient::clientFinishUserMovedResized, this, configure);
     } else if (m_xdgShellPopup) {
         connect(m_xdgShellPopup, &XdgShellPopupInterface::grabRequested, this, [this](SeatInterface *seat, quint32 serial) {
             Q_UNUSED(seat)
             Q_UNUSED(serial)
             //TODO - should check the parent had focus
             m_hasPopupGrab = true;
         });
 
         connect(m_xdgShellPopup, &XdgShellPopupInterface::configureAcknowledged, this, [this](int serial) {
            m_lastAckedConfigureRequest = serial;
         });
 
         QRect position = QRect(m_xdgShellPopup->transientOffset(), m_xdgShellPopup->initialSize());
         m_xdgShellPopup->configure(position);
 
         connect(m_xdgShellPopup, &XdgShellPopupInterface::destroyed, this, &ShellClient::destroyClient);
     }
 
     // set initial desktop
     setDesktop(rules()->checkDesktop(m_internal ? int(NET::OnAllDesktops) : VirtualDesktopManager::self()->current(), true));
     // TODO: merge in checks from Client::manage?
     if (rules()->checkMinimize(false, true)) {
         minimize(true);   // No animation
     }
     setSkipTaskbar(rules()->checkSkipTaskbar(m_plasmaShellSurface ? m_plasmaShellSurface->skipTaskbar() : false, true));
     setSkipPager(rules()->checkSkipPager(false, true));
     setSkipSwitcher(rules()->checkSkipSwitcher(false, true));
     setKeepAbove(rules()->checkKeepAbove(false, true));
     setKeepBelow(rules()->checkKeepBelow(false, true));
     setShortcut(rules()->checkShortcut(QString(), true));
 
     // setup shadow integration
     getShadow();
     connect(s, &SurfaceInterface::shadowChanged, this, &Toplevel::getShadow);
 
     connect(waylandServer(), &WaylandServer::foreignTransientChanged, this, [this](KWayland::Server::SurfaceInterface *child) {
         if (child == surface()) {
             setTransient();
         }
     });
     setTransient();
 
     AbstractClient::updateColorScheme(QString());
 
     if (!m_internal) {
         discardTemporaryRules();
         applyWindowRules(); // Just in case
         RuleBook::self()->discardUsed(this, false);   // Remove ApplyNow rules
         updateWindowRules(Rules::All); // Was blocked while !isManaged()
     }
 }
 
 void ShellClient::destroyClient()
 {
     m_closing = true;
     Deleted *del = nullptr;
     if (workspace()) {
         del = Deleted::create(this);
     }
     emit windowClosed(this, del);
     destroyWindowManagementInterface();
     destroyDecoration();
 
     if (workspace()) {
         StackingUpdatesBlocker blocker(workspace());
         if (transientFor()) {
             transientFor()->removeTransient(this);
         }
         for (auto it = transients().constBegin(); it != transients().constEnd();) {
             if ((*it)->transientFor() == this) {
                 removeTransient(*it);
                 it = transients().constBegin(); // restart, just in case something more has changed with the list
             } else {
                 ++it;
             }
         }
     }
     waylandServer()->removeClient(this);
 
     if (del) {
         del->unrefWindow();
     }
     m_shellSurface = nullptr;
     m_xdgShellSurface = nullptr;
     m_xdgShellPopup = nullptr;
     deleteClient(this);
 }
 
 void ShellClient::deleteClient(ShellClient *c)
 {
     delete c;
 }
 
 QStringList ShellClient::activities() const
 {
     // TODO: implement
     return QStringList();
 }
 
 QPoint ShellClient::clientContentPos() const
 {
     return -1 * clientPos();
 }
 
 QSize ShellClient::clientSize() const
 {
     return m_clientSize;
 }
 
 void ShellClient::debug(QDebug &stream) const
 {
     stream.nospace();
     stream << "\'ShellClient:" << surface() << ";WMCLASS:" << resourceClass() << ":"
            << resourceName() << ";Caption:" << caption() << "\'";
 }
 
 Layer ShellClient::layerForDock() const
 {
     if (m_plasmaShellSurface) {
         switch (m_plasmaShellSurface->panelBehavior()) {
         case PlasmaShellSurfaceInterface::PanelBehavior::WindowsCanCover:
             return NormalLayer;
         case PlasmaShellSurfaceInterface::PanelBehavior::AutoHide:
             return AboveLayer;
         case PlasmaShellSurfaceInterface::PanelBehavior::WindowsGoBelow:
         case PlasmaShellSurfaceInterface::PanelBehavior::AlwaysVisible:
             return DockLayer;
         default:
             Q_UNREACHABLE();
             break;
         }
     }
     return AbstractClient::layerForDock();
 }
 
 QRect ShellClient::transparentRect() const
 {
     // TODO: implement
     return QRect();
 }
 
 NET::WindowType ShellClient::windowType(bool direct, int supported_types) const
 {
     // TODO: implement
     Q_UNUSED(direct)
     Q_UNUSED(supported_types)
     return m_windowType;
 }
 
 double ShellClient::opacity() const
 {
     return m_opacity;
 }
 
 void ShellClient::setOpacity(double opacity)
 {
     const qreal newOpacity = qBound(0.0, opacity, 1.0);
     if (newOpacity == m_opacity) {
         return;
     }
     const qreal oldOpacity = m_opacity;
     m_opacity = newOpacity;
     addRepaintFull();
     emit opacityChanged(this, oldOpacity);
 }
 
 void ShellClient::addDamage(const QRegion &damage)
 {
     auto s = surface();
     if (s->size().isValid()) {
         m_clientSize = s->size();
         updatePendingGeometry();
     }
     markAsMapped();
     setDepth((s->buffer()->hasAlphaChannel() && !isDesktop()) ? 32 : 24);
     repaints_region += damage.translated(clientPos());
     Toplevel::addDamage(damage);
 }
 
 void ShellClient::setInternalFramebufferObject(const QSharedPointer<QOpenGLFramebufferObject> &fbo)
 {
     if (fbo.isNull()) {
         unmap();
         return;
     }
 
     m_clientSize = fbo->size() / surface()->scale();
     markAsMapped();
     doSetGeometry(QRect(geom.topLeft(), m_clientSize));
     Toplevel::setInternalFramebufferObject(fbo);
     Toplevel::addDamage(QRegion(0, 0, width(), height()));
 }
 
 void ShellClient::markAsMapped()
 {
     if (!m_unmapped) {
         return;
     }
 
     m_unmapped = false;
     if (!ready_for_painting) {
         setReadyForPainting();
     } else {
         addRepaintFull();
         emit windowShown(this);
     }
     if (shouldExposeToWindowManagement()) {
         setupWindowManagementInterface();
     }
     updateShowOnScreenEdge();
 }
 
 void ShellClient::createDecoration(const QRect &oldGeom)
 {
     KDecoration2::Decoration *decoration = Decoration::DecorationBridge::self()->createDecoration(this);
     if (decoration) {
         QMetaObject::invokeMethod(decoration, "update", Qt::QueuedConnection);
         connect(decoration, &KDecoration2::Decoration::shadowChanged, this, &Toplevel::getShadow);
         connect(decoration, &KDecoration2::Decoration::bordersChanged, this,
             [this]() {
                 GeometryUpdatesBlocker blocker(this);
                 RequestGeometryBlocker requestBlocker(this);
                 QRect oldgeom = geometry();
                 if (!isShade())
                     checkWorkspacePosition(oldgeom);
                 emit geometryShapeChanged(this, oldgeom);
             }
         );
     }
     setDecoration(decoration);
     // TODO: ensure the new geometry still fits into the client area (e.g. maximized windows)
     doSetGeometry(QRect(oldGeom.topLeft(), m_clientSize + (decoration ? QSize(decoration->borderLeft() + decoration->borderRight(),
                                                                decoration->borderBottom() + decoration->borderTop()) : QSize())));
 
     emit geometryShapeChanged(this, oldGeom);
 }
 
 void ShellClient::updateDecoration(bool check_workspace_pos, bool force)
 {
     if (!force &&
             ((!isDecorated() && noBorder()) || (isDecorated() && !noBorder())))
         return;
     QRect oldgeom = geometry();
     QRect oldClientGeom = oldgeom.adjusted(borderLeft(), borderTop(), -borderRight(), -borderBottom());
     blockGeometryUpdates(true);
     if (force)
         destroyDecoration();
     if (!noBorder()) {
         createDecoration(oldgeom);
     } else
         destroyDecoration();
     if (m_serverDecoration && isDecorated()) {
         m_serverDecoration->setMode(KWayland::Server::ServerSideDecorationManagerInterface::Mode::Server);
     }
     if (m_xdgDecoration) {
         auto mode = isDecorated() ? XdgDecorationInterface::Mode::ServerSide: XdgDecorationInterface::Mode::ClientSide;
         m_xdgDecoration->configure(mode);
         m_xdgShellSurface->configure(xdgSurfaceStates(), m_requestedClientSize);
     }
     getShadow();
     if (check_workspace_pos)
         checkWorkspacePosition(oldgeom, -2, oldClientGeom);
     blockGeometryUpdates(false);
 }
 
 void ShellClient::setGeometry(int x, int y, int w, int h, ForceGeometry_t force)
 {
     if (areGeometryUpdatesBlocked()) {
         // when the GeometryUpdateBlocker exits the current geom is passed to setGeometry
         // thus we need to set it here.
         geom = QRect(x, y, w, h);
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     if (pendingGeometryUpdate() != PendingGeometryNone) {
         // reset geometry to the one before blocking, so that we can compare properly
         geom = geometryBeforeUpdateBlocking();
     }
     // TODO: better merge with Client's implementation
     const QSize requestedClientSize = QSize(w, h) - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
     if (requestedClientSize == m_clientSize && !isWaitingForMoveResizeSync()) {
         // size didn't change, update directly
         doSetGeometry(QRect(x, y, w, h));
         updateMaximizeMode(m_requestedMaximizeMode);
     } else {
         // size did change, Client needs to provide a new buffer
         requestGeometry(QRect(x, y, w, h));
     }
 }
 
 void ShellClient::doSetGeometry(const QRect &rect)
 {
     if (geom == rect && pendingGeometryUpdate() == PendingGeometryNone) {
         return;
     }
     if (!m_unmapped) {
         addWorkspaceRepaint(visibleRect());
     }
     geom = rect;
 
     if (m_unmapped && m_geomMaximizeRestore.isEmpty() && !geom.isEmpty()) {
         // use first valid geometry as restore geometry
         m_geomMaximizeRestore = geom;
     }
 
     if (!m_unmapped) {
         addWorkspaceRepaint(visibleRect());
     }
     syncGeometryToInternalWindow();
     if (hasStrut()) {
         workspace()->updateClientArea();
     }
     const auto old = geometryBeforeUpdateBlocking();
     updateGeometryBeforeUpdateBlocking();
     emit geometryShapeChanged(this, old);
 
     if (isResize()) {
         performMoveResize();
     }
 }
 
 void ShellClient::doMove(int x, int y)
 {
     Q_UNUSED(x)
     Q_UNUSED(y)
     syncGeometryToInternalWindow();
 }
 
 void ShellClient::syncGeometryToInternalWindow()
 {
     if (!m_internalWindow) {
         return;
     }
     const QRect windowRect = QRect(geom.topLeft() + QPoint(borderLeft(), borderTop()),
                                     geom.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom()));
     if (m_internalWindow->geometry() != windowRect) {
         // delay to end of cycle to prevent freeze, see BUG 384441
         QTimer::singleShot(0, m_internalWindow, std::bind(static_cast<void (QWindow::*)(const QRect&)>(&QWindow::setGeometry), m_internalWindow, windowRect));
     }
 }
 
 QByteArray ShellClient::windowRole() const
 {
     return QByteArray();
 }
 
 bool ShellClient::belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const
 {
     if (checks.testFlag(SameApplicationCheck::AllowCrossProcesses)) {
         if (other->desktopFileName() == desktopFileName()) {
             return true;
         }
     }
     if (auto s = other->surface()) {
         return s->client() == surface()->client();
     }
     return false;
 }
 
 void ShellClient::blockActivityUpdates(bool b)
 {
     Q_UNUSED(b)
 }
 
 void ShellClient::updateCaption()
 {
     const QString oldSuffix = m_captionSuffix;
     const auto shortcut = shortcutCaptionSuffix();
     m_captionSuffix = shortcut;
     if ((!isSpecialWindow() || isToolbar()) && findClientWithSameCaption()) {
         int i = 2;
         do {
             m_captionSuffix = shortcut + QLatin1String(" <") + QString::number(i) + QLatin1Char('>');
             i++;
         } while (findClientWithSameCaption());
     }
     if (m_captionSuffix != oldSuffix) {
         emit captionChanged();
     }
 }
 
 void ShellClient::closeWindow()
 {
     if (m_xdgShellSurface && isCloseable()) {
         m_xdgShellSurface->close();
         const qint32 pingSerial = static_cast<XdgShellInterface *>(m_xdgShellSurface->global())->ping(m_xdgShellSurface);
         m_pingSerials.insert(pingSerial, PingReason::CloseWindow);
-    } else if (m_qtExtendedSurface && isCloseable()) {
-        m_qtExtendedSurface->close();
     } else if (m_internalWindow) {
         m_internalWindow->hide();
     }
 }
 
 AbstractClient *ShellClient::findModal(bool allow_itself)
 {
     Q_UNUSED(allow_itself)
     return nullptr;
 }
 
 bool ShellClient::isCloseable() const
 {
     if (m_windowType == NET::Desktop || m_windowType == NET::Dock) {
         return false;
     }
     if (m_xdgShellSurface) {
         return true;
     }
     if (m_internal) {
         return true;
     }
-    return m_qtExtendedSurface ? true : false;
+    return false;
 }
 
 bool ShellClient::isFullScreen() const
 {
     return m_fullScreen;
 }
 
 bool ShellClient::isMaximizable() const
 {
     if (m_internal) {
         return false;
     }
     return true;
 }
 
 bool ShellClient::isMinimizable() const
 {
     if (m_internal) {
         return false;
     }
     return (!m_plasmaShellSurface || m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal);
 }
 
 bool ShellClient::isMovable() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool ShellClient::isMovableAcrossScreens() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool ShellClient::isResizable() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool ShellClient::isShown(bool shaded_is_shown) const
 {
     Q_UNUSED(shaded_is_shown)
     return !m_closing && !m_unmapped && !isMinimized() && !m_hidden;
 }
 
 void ShellClient::hideClient(bool hide)
 {
     if (m_hidden == hide) {
         return;
     }
     m_hidden = hide;
     if (hide) {
         addWorkspaceRepaint(visibleRect());
         workspace()->clientHidden(this);
         emit windowHidden(this);
     } else {
         emit windowShown(this);
     }
 }
 
 static bool changeMaximizeRecursion = false;
 void ShellClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     if (changeMaximizeRecursion) {
         return;
     }
 
     if (!isResizable()) {
         return;
     }
 
     const QRect clientArea = isElectricBorderMaximizing() ?
         workspace()->clientArea(MaximizeArea, Cursor::pos(), desktop()) :
         workspace()->clientArea(MaximizeArea, this);
 
     const MaximizeMode oldMode = m_requestedMaximizeMode;
     const QRect oldGeometry = geometry();
 
     StackingUpdatesBlocker blocker(workspace());
     RequestGeometryBlocker geometryBlocker(this);
     // 'adjust == true' means to update the size only, e.g. after changing workspace size
     if (!adjust) {
         if (vertical)
             m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeVertical);
         if (horizontal)
             m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeHorizontal);
     }
     // TODO: add more checks as in Client
 
     // call into decoration update borders
     if (isDecorated() && decoration()->client() && !(options->borderlessMaximizedWindows() && m_requestedMaximizeMode == KWin::MaximizeFull)) {
         changeMaximizeRecursion = true;
         const auto c = decoration()->client().data();
         if ((m_requestedMaximizeMode & MaximizeVertical) != (oldMode & MaximizeVertical)) {
             emit c->maximizedVerticallyChanged(m_requestedMaximizeMode & MaximizeVertical);
         }
         if ((m_requestedMaximizeMode & MaximizeHorizontal) != (oldMode & MaximizeHorizontal)) {
             emit c->maximizedHorizontallyChanged(m_requestedMaximizeMode & MaximizeHorizontal);
         }
         if ((m_requestedMaximizeMode == MaximizeFull) != (oldMode == MaximizeFull)) {
             emit c->maximizedChanged(m_requestedMaximizeMode & MaximizeFull);
         }
         changeMaximizeRecursion = false;
     }
 
     if (options->borderlessMaximizedWindows()) {
         // triggers a maximize change.
         // The next setNoBorder interation will exit since there's no change but the first recursion pullutes the restore geometry
         changeMaximizeRecursion = true;
         setNoBorder(rules()->checkNoBorder(m_requestedMaximizeMode == MaximizeFull));
         changeMaximizeRecursion = false;
     }
 
     // Conditional quick tiling exit points
     const auto oldQuickTileMode = quickTileMode();
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         if (oldMode == MaximizeFull &&
                 !clientArea.contains(m_geomMaximizeRestore.center())) {
             // Not restoring on the same screen
             // TODO: The following doesn't work for some reason
             //quick_tile_mode = QuickTileNone; // And exit quick tile mode manually
         } else if ((oldMode == MaximizeVertical && m_requestedMaximizeMode == MaximizeRestore) ||
                   (oldMode == MaximizeFull && m_requestedMaximizeMode == MaximizeHorizontal)) {
             // Modifying geometry of a tiled window
             updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry
         }
     }
 
     // TODO: check rules
     if (m_requestedMaximizeMode == MaximizeFull) {
         m_geomMaximizeRestore = oldGeometry;
         // TODO: Client has more checks
         if (options->electricBorderMaximize()) {
             updateQuickTileMode(QuickTileFlag::Maximize);
         } else {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
         setGeometry(workspace()->clientArea(MaximizeArea, this));
         workspace()->raiseClient(this);
     } else {
         if (m_requestedMaximizeMode == MaximizeRestore) {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
 
         if (m_geomMaximizeRestore.isValid()) {
             setGeometry(m_geomMaximizeRestore);
         } else {
             setGeometry(workspace()->clientArea(PlacementArea, this));
         }
     }
 }
 
 MaximizeMode ShellClient::maximizeMode() const
 {
     return m_maximizeMode;
 }
 
 MaximizeMode ShellClient::requestedMaximizeMode() const
 {
     return m_requestedMaximizeMode;
 }
 
 bool ShellClient::noBorder() const
 {
     if (isInternal()) {
         return m_internalWindowFlags.testFlag(Qt::FramelessWindowHint) || m_internalWindowFlags.testFlag(Qt::Popup);
     }
     if (m_serverDecoration) {
         if (m_serverDecoration->mode() == ServerSideDecorationManagerInterface::Mode::Server) {
             return m_userNoBorder || isFullScreen();
         }
     }
     if (m_xdgDecoration && m_xdgDecoration->requestedMode() != XdgDecorationInterface::Mode::ClientSide) {
         return m_userNoBorder || isFullScreen();
     }
     return true;
 }
 
 void ShellClient::setFullScreen(bool set, bool user)
 {
     if (!isFullScreen() && !set)
         return;
     if (user && !userCanSetFullScreen())
         return;
     set = rules()->checkFullScreen(set && !isSpecialWindow());
     setShade(ShadeNone);
     bool was_fs = isFullScreen();
     if (was_fs) {
         workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
     } else {
         // in shell surface, maximise mode and fullscreen are exclusive
         // fullscreen->toplevel should restore the state we had before maximising
         if (m_shellSurface && m_maximizeMode == MaximizeMode::MaximizeFull) {
             m_geomFsRestore = m_geomMaximizeRestore;
         } else {
             m_geomFsRestore = geometry();
         }
     }
     m_fullScreen = set;
     if (was_fs == isFullScreen())
         return;
     if (set) {
         untab();
         workspace()->raiseClient(this);
     }
     RequestGeometryBlocker requestBlocker(this);
     StackingUpdatesBlocker blocker1(workspace());
     GeometryUpdatesBlocker blocker2(this);
     workspace()->updateClientLayer(this);   // active fullscreens get different layer
     updateDecoration(false, false);
     if (isFullScreen()) {
         setGeometry(workspace()->clientArea(FullScreenArea, this));
     } else {
         if (!m_geomFsRestore.isNull()) {
             int currentScreen = screen();
             setGeometry(QRect(m_geomFsRestore.topLeft(), adjustedSize(m_geomFsRestore.size())));
             if( currentScreen != screen())
                 workspace()->sendClientToScreen( this, currentScreen );
         } else {
             // does this ever happen?
             setGeometry(workspace()->clientArea(MaximizeArea, this));
         }
     }
     updateWindowRules(Rules::Fullscreen|Rules::Position|Rules::Size);
 
     if (was_fs != isFullScreen()) {
         emit fullScreenChanged();
     }
 }
 
 void ShellClient::setNoBorder(bool set)
 {
     if (!userCanSetNoBorder()) {
         return;
     }
     set = rules()->checkNoBorder(set);
     if (m_userNoBorder == set) {
         return;
     }
     m_userNoBorder = set;
     updateDecoration(true, false);
     updateWindowRules(Rules::NoBorder);
 }
 
 void ShellClient::setOnAllActivities(bool set)
 {
     Q_UNUSED(set)
 }
 
 void ShellClient::takeFocus()
 {
     if (rules()->checkAcceptFocus(wantsInput())) {
         if (m_xdgShellSurface) {
             const qint32 pingSerial = static_cast<XdgShellInterface *>(m_xdgShellSurface->global())->ping(m_xdgShellSurface);
             m_pingSerials.insert(pingSerial, PingReason::FocusWindow);
         }
         setActive(true);
     }
 
     bool breakShowingDesktop = !keepAbove() && !isOnScreenDisplay();
     if (breakShowingDesktop) {
         // check that it doesn't belong to the desktop
         const auto &clients = waylandServer()->clients();
         for (auto c: clients) {
             if (!belongsToSameApplication(c, SameApplicationChecks())) {
                 continue;
             }
             if (c->isDesktop()) {
                 breakShowingDesktop = false;
                 break;
             }
         }
     }
     if (breakShowingDesktop)
         workspace()->setShowingDesktop(false);
 }
 
 void ShellClient::doSetActive()
 {
     if (!isActive()) {
         return;
     }
     StackingUpdatesBlocker blocker(workspace());
     workspace()->focusToNull();
 }
 
 bool ShellClient::userCanSetFullScreen() const
 {
     if (m_xdgShellSurface) {
         return true;
     }
     return false;
 }
 
 bool ShellClient::userCanSetNoBorder() const
 {
     if (m_serverDecoration && m_serverDecoration->mode() == ServerSideDecorationManagerInterface::Mode::Server) {
         return !isFullScreen() && !isShade() && !tabGroup();
     }
     if (m_xdgDecoration && m_xdgDecoration->requestedMode() != XdgDecorationInterface::Mode::ClientSide) {
         return !isFullScreen() && !isShade() && !tabGroup();
     }
     if (m_internal) {
         return !m_internalWindowFlags.testFlag(Qt::FramelessWindowHint) || m_internalWindowFlags.testFlag(Qt::Popup);
     }
     return false;
 }
 
 bool ShellClient::wantsInput() const
 {
     return rules()->checkAcceptFocus(acceptsFocus());
 }
 
 bool ShellClient::acceptsFocus() const
 {
     if (isInternal()) {
         return false;
     }
     if (waylandServer()->inputMethodConnection() == surface()->client()) {
         return false;
     }
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::OnScreenDisplay ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::ToolTip ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Notification) {
             return false;
         }
     }
     if (m_closing) {
         // a closing window does not accept focus
         return false;
     }
     if (m_unmapped) {
         // an unmapped window does not accept focus
         return false;
     }
     if (m_shellSurface) {
         if (m_shellSurface->isPopup()) {
             return false;
         }
         return m_shellSurface->acceptsKeyboardFocus();
     }
     if (m_xdgShellSurface) {
         // TODO: proper
         return true;
     }
     return false;
 }
 
 void ShellClient::createWindowId()
 {
     if (m_internalWindow) {
         m_windowId = m_internalWindow->winId();
     } else {
         m_windowId = waylandServer()->createWindowId(surface());
     }
 }
 
 void ShellClient::findInternalWindow()
 {
     if (surface()->client() != waylandServer()->internalConnection()) {
         return;
     }
     const QWindowList windows = kwinApp()->topLevelWindows();
     for (QWindow *w: windows) {
         auto s = KWayland::Client::Surface::fromWindow(w);
         if (!s) {
             continue;
         }
         if (s->id() != surface()->id()) {
             continue;
         }
         m_internalWindow = w;
         m_internalWindowFlags = m_internalWindow->flags();
         connect(m_internalWindow, &QWindow::xChanged, this, &ShellClient::updateInternalWindowGeometry);
         connect(m_internalWindow, &QWindow::yChanged, this, &ShellClient::updateInternalWindowGeometry);
         connect(m_internalWindow, &QWindow::destroyed, this, [this] { m_internalWindow = nullptr; });
         connect(m_internalWindow, &QWindow::opacityChanged, this, &ShellClient::setOpacity);
 
         const QVariant windowType = m_internalWindow->property("kwin_windowType");
         if (!windowType.isNull()) {
             m_windowType = windowType.value<NET::WindowType>();
         }
         setOpacity(m_internalWindow->opacity());
 
         // skip close animation support
         setSkipCloseAnimation(m_internalWindow->property(s_skipClosePropertyName).toBool());
         m_internalWindow->installEventFilter(this);
         return;
     }
 }
 
 void ShellClient::updateInternalWindowGeometry()
 {
     if (!m_internalWindow) {
         return;
     }
     doSetGeometry(QRect(m_internalWindow->geometry().topLeft() - QPoint(borderLeft(), borderTop()),
                         m_internalWindow->geometry().size() + QSize(borderLeft() + borderRight(), borderTop() + borderBottom())));
 }
 
 pid_t ShellClient::pid() const
 {
     return surface()->client()->processId();
 }
 
 bool ShellClient::isInternal() const
 {
     return m_internal;
 }
 
 bool ShellClient::isLockScreen() const
 {
     if (m_internalWindow) {
         return m_internalWindow->property("org_kde_ksld_emergency").toBool();
     }
     return surface()->client() == waylandServer()->screenLockerClientConnection();
 }
 
 bool ShellClient::isInputMethod() const
 {
     if (m_internal && m_internalWindow) {
         return m_internalWindow->property("__kwin_input_method").toBool();
     }
     return surface()->client() == waylandServer()->inputMethodConnection();
 }
 
 void ShellClient::requestGeometry(const QRect &rect)
 {
     if (m_requestGeometryBlockCounter != 0) {
         m_blockedRequestGeometry = rect;
         return;
     }
     PendingConfigureRequest configureRequest;
     configureRequest.positionAfterResize = rect.topLeft();
     configureRequest.maximizeMode = m_requestedMaximizeMode;
 
     const QSize size = rect.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
     m_requestedClientSize = size;
 
     if (m_shellSurface) {
         m_shellSurface->requestSize(size);
     }
     if (m_xdgShellSurface) {
         configureRequest.serialId = m_xdgShellSurface->configure(xdgSurfaceStates(), size);
     }
     if (m_xdgShellPopup) {
         auto parent = transientFor();
         if (parent) {
             const QPoint globalClientContentPos = parent->geometry().topLeft() + parent->clientPos();
             const QPoint relativeOffset = rect.topLeft() -globalClientContentPos;
             configureRequest.serialId = m_xdgShellPopup->configure(QRect(relativeOffset, rect.size()));
         }
     }
 
     m_pendingConfigureRequests.append(configureRequest);
 
     m_blockedRequestGeometry = QRect();
     if (m_internal) {
         m_internalWindow->setGeometry(QRect(rect.topLeft() + QPoint(borderLeft(), borderTop()), rect.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom())));
     }
 }
 
 void ShellClient::updatePendingGeometry()
 {
     QPoint position = geom.topLeft();
     MaximizeMode maximizeMode = m_maximizeMode;
     for (auto it = m_pendingConfigureRequests.begin(); it != m_pendingConfigureRequests.end(); it++) {
         if (it->serialId > m_lastAckedConfigureRequest) {
             //this serial is not acked yet, therefore we know all future serials are not
             break;
         }
         if (it->serialId == m_lastAckedConfigureRequest) {
             if (position != it->positionAfterResize) {
                 addLayerRepaint(geometry());
             }
             position = it->positionAfterResize;
             maximizeMode = it->maximizeMode;
 
             m_pendingConfigureRequests.erase(m_pendingConfigureRequests.begin(), ++it);
             break;
         }
         //else serialId < m_lastAckedConfigureRequest and the state is now irrelevant and can be ignored
     }
     doSetGeometry(QRect(position, m_clientSize + QSize(borderLeft() + borderRight(), borderTop() + borderBottom())));
     updateMaximizeMode(maximizeMode);
 }
 
 void ShellClient::clientFullScreenChanged(bool fullScreen)
 {
     setFullScreen(fullScreen, false);
 }
 
 void ShellClient::resizeWithChecks(int w, int h, ForceGeometry_t force)
 {
     Q_UNUSED(force)
     QRect area = workspace()->clientArea(WorkArea, this);
     // don't allow growing larger than workarea
     if (w > area.width()) {
         w = area.width();
     }
     if (h > area.height()) {
         h = area.height();
     }
     if (m_shellSurface) {
         m_shellSurface->requestSize(QSize(w, h));
     }
     if (m_xdgShellSurface) {
         m_xdgShellSurface->configure(xdgSurfaceStates(), QSize(w, h));
     }
     if (m_internal) {
         m_internalWindow->setGeometry(QRect(pos() + QPoint(borderLeft(), borderTop()), QSize(w, h) - QSize(borderLeft() + borderRight(), borderTop() + borderBottom())));
     }
 }
 
 void ShellClient::unmap()
 {
     m_unmapped = true;
     m_requestedClientSize = QSize(0, 0);
     destroyWindowManagementInterface();
     if (Workspace::self()) {
         addWorkspaceRepaint(visibleRect());
         workspace()->clientHidden(this);
     }
     emit windowHidden(this);
 }
 
 void ShellClient::installPlasmaShellSurface(PlasmaShellSurfaceInterface *surface)
 {
     m_plasmaShellSurface = surface;
     auto updatePosition = [this, surface] {
         QRect rect = QRect(surface->position(), m_clientSize + QSize(borderLeft() + borderRight(), borderTop() + borderBottom()));
         // Shell surfaces of internal windows are sometimes desync to current value.
         // Make sure to not set window geometry of internal windows to invalid values (bug 386304)
         if (!m_internal || rect.isValid()) {
             doSetGeometry(rect);
         }
     };
     auto updateRole = [this, surface] {
         NET::WindowType type = NET::Unknown;
         switch (surface->role()) {
         case PlasmaShellSurfaceInterface::Role::Desktop:
             type = NET::Desktop;
             break;
         case PlasmaShellSurfaceInterface::Role::Panel:
             type = NET::Dock;
             break;
         case PlasmaShellSurfaceInterface::Role::OnScreenDisplay:
             type = NET::OnScreenDisplay;
             break;
         case PlasmaShellSurfaceInterface::Role::Notification:
             type = NET::Notification;
             break;
         case PlasmaShellSurfaceInterface::Role::ToolTip:
             type = NET::Tooltip;
             break;
         case PlasmaShellSurfaceInterface::Role::Normal:
         default:
             type = NET::Normal;
             break;
         }
         if (type != m_windowType) {
             m_windowType = type;
             if (m_windowType == NET::Desktop || type == NET::Dock || type == NET::OnScreenDisplay || type == NET::Notification || type == NET::Tooltip) {
                 setOnAllDesktops(true);
             }
             workspace()->updateClientArea();
         }
     };
     connect(surface, &PlasmaShellSurfaceInterface::positionChanged, this, updatePosition);
     connect(surface, &PlasmaShellSurfaceInterface::roleChanged, this, updateRole);
     connect(surface, &PlasmaShellSurfaceInterface::panelBehaviorChanged, this,
         [this] {
             updateShowOnScreenEdge();
             workspace()->updateClientArea();
         }
     );
     connect(surface, &PlasmaShellSurfaceInterface::panelAutoHideHideRequested, this,
         [this] {
             hideClient(true);
             m_plasmaShellSurface->hideAutoHidingPanel();
             updateShowOnScreenEdge();
         }
     );
     connect(surface, &PlasmaShellSurfaceInterface::panelAutoHideShowRequested, this,
         [this] {
             hideClient(false);
             ScreenEdges::self()->reserve(this, ElectricNone);
             m_plasmaShellSurface->showAutoHidingPanel();
         }
     );
     updatePosition();
     updateRole();
     updateShowOnScreenEdge();
     connect(this, &ShellClient::geometryChanged, this, &ShellClient::updateShowOnScreenEdge);
 
     setSkipTaskbar(surface->skipTaskbar());
     connect(surface, &PlasmaShellSurfaceInterface::skipTaskbarChanged, this, [this] {
         setSkipTaskbar(m_plasmaShellSurface->skipTaskbar());
     });
 
     setSkipSwitcher(surface->skipSwitcher());
     connect(surface, &PlasmaShellSurfaceInterface::skipSwitcherChanged, this, [this] {
         setSkipSwitcher(m_plasmaShellSurface->skipSwitcher());
     });
 }
 
 void ShellClient::updateShowOnScreenEdge()
 {
     if (!ScreenEdges::self()) {
         return;
     }
     if (m_unmapped || !m_plasmaShellSurface || m_plasmaShellSurface->role() != PlasmaShellSurfaceInterface::Role::Panel) {
         ScreenEdges::self()->reserve(this, ElectricNone);
         return;
     }
     if ((m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AutoHide && m_hidden) ||
         m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::WindowsCanCover) {
         // screen edge API requires an edge, thus we need to figure out which edge the window borders
         Qt::Edges edges;
         for (int i = 0; i < screens()->count(); i++) {
             const auto &screenGeo = screens()->geometry(i);
             if (screenGeo.x() == geom.x()) {
                 edges |= Qt::LeftEdge;
             }
             if (screenGeo.x() + screenGeo.width() == geom.x() + geom.width()) {
                 edges |= Qt::RightEdge;
             }
             if (screenGeo.y() == geom.y()) {
                 edges |= Qt::TopEdge;
             }
             if (screenGeo.y() + screenGeo.height() == geom.y() + geom.height()) {
                 edges |= Qt::BottomEdge;
             }
         }
         // a panel might border multiple screen edges. E.g. a horizontal panel at the bottom will
         // also border the left and right edge
         // let's remove such cases
         if (edges.testFlag(Qt::LeftEdge) && edges.testFlag(Qt::RightEdge)) {
             edges = edges & (~(Qt::LeftEdge | Qt::RightEdge));
         }
         if (edges.testFlag(Qt::TopEdge) && edges.testFlag(Qt::BottomEdge)) {
             edges = edges & (~(Qt::TopEdge | Qt::BottomEdge));
         }
         // it's still possible that a panel borders two edges, e.g. bottom and left
         // in that case the one which is sharing more with the edge wins
         auto check = [this](Qt::Edges edges, Qt::Edge horiz, Qt::Edge vert) {
             if (edges.testFlag(horiz) && edges.testFlag(vert)) {
                 if (geom.width() >= geom.height()) {
                     return edges & ~horiz;
                 } else {
                     return edges & ~vert;
                 }
             }
             return edges;
         };
         edges = check(edges, Qt::LeftEdge, Qt::TopEdge);
         edges = check(edges, Qt::LeftEdge, Qt::BottomEdge);
         edges = check(edges, Qt::RightEdge, Qt::TopEdge);
         edges = check(edges, Qt::RightEdge, Qt::BottomEdge);
 
         ElectricBorder border = ElectricNone;
         if (edges.testFlag(Qt::LeftEdge)) {
             border = ElectricLeft;
         }
         if (edges.testFlag(Qt::RightEdge)) {
             border = ElectricRight;
         }
         if (edges.testFlag(Qt::TopEdge)) {
             border = ElectricTop;
         }
         if (edges.testFlag(Qt::BottomEdge)) {
             border = ElectricBottom;
         }
         ScreenEdges::self()->reserve(this, border);
     } else {
         ScreenEdges::self()->reserve(this, ElectricNone);
     }
 }
 
 bool ShellClient::isInitialPositionSet() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->isPositionSet();
     }
     return false;
 }
 
-void ShellClient::installQtExtendedSurface(QtExtendedSurfaceInterface *surface)
-{
-    m_qtExtendedSurface = surface;
-
-    connect(m_qtExtendedSurface.data(), &QtExtendedSurfaceInterface::raiseRequested, this, [this]() {
-        workspace()->raiseClientRequest(this);
-    });
-    connect(m_qtExtendedSurface.data(), &QtExtendedSurfaceInterface::lowerRequested, this, [this]() {
-        workspace()->lowerClientRequest(this);
-    });
-    m_qtExtendedSurface->installEventFilter(this);
-}
-
 void ShellClient::installAppMenu(AppMenuInterface *menu)
 {
     m_appMenuInterface = menu;
 
     auto updateMenu = [this](AppMenuInterface::InterfaceAddress address) {
         updateApplicationMenuServiceName(address.serviceName);
         updateApplicationMenuObjectPath(address.objectPath);
     };
     connect(m_appMenuInterface, &AppMenuInterface::addressChanged, this, [=](AppMenuInterface::InterfaceAddress address) {
         updateMenu(address);
     });
     updateMenu(menu->address());
 }
 
 void ShellClient::installPalette(ServerSideDecorationPaletteInterface *palette)
 {
     m_paletteInterface = palette;
 
     auto updatePalette = [this](const QString &palette) {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(palette));
     };
     connect(m_paletteInterface, &ServerSideDecorationPaletteInterface::paletteChanged, this, [=](const QString &palette) {
         updatePalette(palette);
     });
     connect(m_paletteInterface, &QObject::destroyed, this, [=]() {
         updatePalette(QString());
     });
     updatePalette(palette->palette());
 }
 
 
 bool ShellClient::eventFilter(QObject *watched, QEvent *event)
 {
     if (watched == m_internalWindow && event->type() == QEvent::DynamicPropertyChange) {
         QDynamicPropertyChangeEvent *pe = static_cast<QDynamicPropertyChangeEvent*>(event);
         if (pe->propertyName() == s_skipClosePropertyName) {
             setSkipCloseAnimation(m_internalWindow->property(s_skipClosePropertyName).toBool());
         }
         if (pe->propertyName() == "kwin_windowType") {
             m_windowType = m_internalWindow->property("kwin_windowType").value<NET::WindowType>();
             workspace()->updateClientArea();
         }
     }
     return false;
 }
 
 void ShellClient::updateColorScheme()
 {
     if (m_paletteInterface) {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(m_paletteInterface->palette()));
     } else {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(QString()));
     }
 }
 
 void ShellClient::updateMaximizeMode(MaximizeMode maximizeMode)
 {
     if (maximizeMode == m_maximizeMode) {
         return;
     }
 
     m_maximizeMode = maximizeMode;
 
     emit clientMaximizedStateChanged(this, m_maximizeMode);
     emit clientMaximizedStateChanged(this, m_maximizeMode & MaximizeHorizontal, m_maximizeMode & MaximizeVertical);
 }
 
 bool ShellClient::hasStrut() const
 {
     if (!isShown(true)) {
         return false;
     }
     if (!m_plasmaShellSurface) {
         return false;
     }
     if (m_plasmaShellSurface->role() != PlasmaShellSurfaceInterface::Role::Panel) {
         return false;
     }
     return m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AlwaysVisible;
 }
 
 void ShellClient::updateIcon()
 {
     const QString waylandIconName = QStringLiteral("wayland");
     const QString dfIconName = iconFromDesktopFile();
     const QString iconName = dfIconName.isEmpty() ? waylandIconName : dfIconName;
     if (iconName == icon().name()) {
         return;
     }
     setIcon(QIcon::fromTheme(iconName));
 }
 
 bool ShellClient::isTransient() const
 {
     return m_transient;
 }
 
 void ShellClient::setTransient()
 {
     SurfaceInterface *s = nullptr;
     if (m_shellSurface) {
         s = m_shellSurface->transientFor().data();
     }
     if (m_xdgShellSurface) {
         if (auto transient = m_xdgShellSurface->transientFor().data()) {
             s = transient->surface();
         }
     }
     if (m_xdgShellPopup) {
         s = m_xdgShellPopup->transientFor().data();
     }
     if (!s) {
         s = waylandServer()->findForeignTransientForSurface(surface());
     }
     auto t = waylandServer()->findClient(s);
     if (t != transientFor()) {
         // remove from main client
         if (transientFor())
             transientFor()->removeTransient(this);
         setTransientFor(t);
         if (t) {
             t->addTransient(this);
         }
     }
     m_transient = (s != nullptr);
 }
 
 bool ShellClient::hasTransientPlacementHint() const
 {
     return isTransient() && transientFor() != nullptr &&
             (m_shellSurface || m_xdgShellPopup);
 }
 
 QRect ShellClient::transientPlacement(const QRect &bounds) const
 {
     QRect anchorRect;
     Qt::Edges anchorEdge;
     Qt::Edges gravity;
     QPoint offset;
     PositionerConstraints constraintAdjustments;
 
     const QPoint parentClientPos = transientFor()->pos() + transientFor()->clientPos();
     QRect popupPosition;
 
     // returns if a target is within the supplied bounds, optional edges argument states which side to check
     auto inBounds = [bounds](const QRect &target, Qt::Edges edges = Qt::LeftEdge | Qt::RightEdge | Qt::TopEdge | Qt::BottomEdge) -> bool {
         if (edges & Qt::LeftEdge && target.left() < bounds.left()) {
             return false;
         }
         if (edges & Qt::TopEdge && target.top() < bounds.top()) {
             return false;
         }
         if (edges & Qt::RightEdge && target.right() > bounds.right()) {
             //normal QRect::right issue cancels out
             return false;
         }
         if (edges & Qt::BottomEdge && target.bottom() > bounds.bottom()) {
             return false;
         }
         return true;
     };
 
     if (m_shellSurface) {
         anchorRect = QRect(m_shellSurface->transientOffset(), QSize(1,1));
         anchorEdge = Qt::TopEdge | Qt::LeftEdge;
         gravity = Qt::BottomEdge | Qt::RightEdge; //our single point represents the top left of the popup
         constraintAdjustments = (PositionerConstraint::SlideX | PositionerConstraint::SlideY);
     } else if (m_xdgShellPopup) {
         anchorRect = m_xdgShellPopup->anchorRect();
         anchorEdge = m_xdgShellPopup->anchorEdge();
         gravity = m_xdgShellPopup->gravity();
         offset = m_xdgShellPopup->anchorOffset();
         constraintAdjustments = m_xdgShellPopup->constraintAdjustments();
     } else {
         Q_UNREACHABLE();
     }
 
     //initial position
     popupPosition = QRect(popupOffset(anchorRect, anchorEdge, gravity) + offset + parentClientPos, geometry().size());
 
     //if that fits, we don't need to do anything
     if (inBounds(popupPosition)) {
         return popupPosition;
     }
     //otherwise apply constraint adjustment per axis in order XDG Shell Popup states
 
     if (constraintAdjustments & PositionerConstraint::FlipX) {
         if (!inBounds(popupPosition, Qt::LeftEdge | Qt::RightEdge)) {
             //flip both edges (if either bit is set, XOR both)
             auto flippedAnchorEdge = anchorEdge;
             if (flippedAnchorEdge & (Qt::LeftEdge | Qt::RightEdge)) {
                 flippedAnchorEdge ^= (Qt::LeftEdge | Qt::RightEdge);
             }
             auto flippedGravity = gravity;
             if (flippedGravity & (Qt::LeftEdge | Qt::RightEdge)) {
                 flippedGravity ^= (Qt::LeftEdge | Qt::RightEdge);
             }
             auto flippedPopupPosition = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity) + offset + parentClientPos, geometry().size());
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupPosition, Qt::LeftEdge | Qt::RightEdge)) {
                 popupPosition.setX(flippedPopupPosition.x());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideX) {
         if (!inBounds(popupPosition, Qt::LeftEdge)) {
             popupPosition.setX(bounds.x());
         }
         if (!inBounds(popupPosition, Qt::RightEdge)) {
             popupPosition.setX(bounds.x() + bounds.width() - geometry().width());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeX) {
         //TODO
         //but we need to sort out when this is run as resize should only happen before first configure
     }
 
     if (constraintAdjustments & PositionerConstraint::FlipY) {
         if (!inBounds(popupPosition, Qt::TopEdge | Qt::BottomEdge)) {
             //flip both edges (if either bit is set, XOR both)
             auto flippedAnchorEdge = anchorEdge;
             if (flippedAnchorEdge & (Qt::TopEdge | Qt::BottomEdge)) {
                 flippedAnchorEdge ^= (Qt::TopEdge | Qt::BottomEdge);
             }
             auto flippedGravity = gravity;
             if (flippedGravity & (Qt::TopEdge | Qt::BottomEdge)) {
                 flippedGravity ^= (Qt::TopEdge | Qt::BottomEdge);
             }
             auto flippedPopupPosition = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity) + offset + parentClientPos, geometry().size());
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupPosition, Qt::TopEdge | Qt::BottomEdge)) {
                 popupPosition.setY(flippedPopupPosition.y());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideY) {
         if (!inBounds(popupPosition, Qt::TopEdge)) {
             popupPosition.setY(bounds.y());
         }
         if (!inBounds(popupPosition, Qt::BottomEdge)) {
             popupPosition.setY(bounds.y() + bounds.height() - geometry().height());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeY) {
         //TODO
     }
 
     return popupPosition;
 }
 
 QPoint ShellClient::popupOffset(const QRect &anchorRect, const Qt::Edges anchorEdge, const Qt::Edges gravity) const
 {
     const QSize popupSize = geometry().size();
     QPoint anchorPoint;
     switch (anchorEdge & (Qt::LeftEdge | Qt::RightEdge)) {
     case Qt::LeftEdge:
         anchorPoint.setX(anchorRect.x());
         break;
     case Qt::RightEdge:
         anchorPoint.setX(anchorRect.x() + anchorRect.width());
         break;
     default:
         anchorPoint.setX(qRound(anchorRect.x() + anchorRect.width() / 2.0));
     }
     switch (anchorEdge & (Qt::TopEdge | Qt::BottomEdge)) {
     case Qt::TopEdge:
         anchorPoint.setY(anchorRect.y());
         break;
     case Qt::BottomEdge:
         anchorPoint.setY(anchorRect.y() + anchorRect.height());
         break;
     default:
         anchorPoint.setY(qRound(anchorRect.y() + anchorRect.height() / 2.0));
     }
 
     // calculate where the top left point of the popup will end up with the applied gravity
     // gravity indicates direction. i.e if gravitating towards the top the popup's bottom edge
     // will next to the anchor point
     QPoint popupPosAdjust;
     switch (gravity & (Qt::LeftEdge | Qt::RightEdge)) {
     case Qt::LeftEdge:
         popupPosAdjust.setX(-popupSize.width());
         break;
     case Qt::RightEdge:
         popupPosAdjust.setX(0);
         break;
     default:
         popupPosAdjust.setX(qRound(-popupSize.width() / 2.0));
     }
     switch (gravity & (Qt::TopEdge | Qt::BottomEdge)) {
     case Qt::TopEdge:
         popupPosAdjust.setY(-popupSize.height());
         break;
     case Qt::BottomEdge:
         popupPosAdjust.setY(0);
         break;
     default:
         popupPosAdjust.setY(qRound(-popupSize.height() / 2.0));
     }
 
     return anchorPoint + popupPosAdjust;
 }
 
 bool ShellClient::isWaitingForMoveResizeSync() const
 {
     return !m_pendingConfigureRequests.isEmpty();
 }
 
 void ShellClient::doResizeSync()
 {
     requestGeometry(moveResizeGeometry());
 }
 
 QMatrix4x4 ShellClient::inputTransformation() const
 {
     QMatrix4x4 m = Toplevel::inputTransformation();
     m.translate(-borderLeft(), -borderTop());
     return m;
 }
 
 void ShellClient::installServerSideDecoration(KWayland::Server::ServerSideDecorationInterface *deco)
 {
     if (m_serverDecoration == deco) {
         return;
     }
     m_serverDecoration = deco;
     connect(m_serverDecoration, &ServerSideDecorationInterface::destroyed, this,
         [this] {
             m_serverDecoration = nullptr;
             if (m_closing || !Workspace::self()) {
                 return;
             }
             if (!m_unmapped) {
                 // maybe delay to next event cycle in case the ShellClient is getting destroyed, too
                 updateDecoration(true);
             }
         }
     );
     if (!m_unmapped) {
         updateDecoration(true);
     }
     connect(m_serverDecoration, &ServerSideDecorationInterface::modeRequested, this,
         [this] (ServerSideDecorationManagerInterface::Mode mode) {
             const bool changed = mode != m_serverDecoration->mode();
             if (changed && !m_unmapped) {
                 updateDecoration(false);
             }
         }
     );
 }
 
 void ShellClient::installXdgDecoration(XdgDecorationInterface *deco)
 {
     Q_ASSERT(m_xdgShellSurface);
 
     m_xdgDecoration = deco;
 
     connect(m_xdgDecoration, &QObject::destroyed, this,
         [this] {
             m_xdgDecoration = nullptr;
             if (m_closing || !Workspace::self()) {
                 return;
             }
             updateDecoration(true);
         }
     );
 
     connect(m_xdgDecoration, &XdgDecorationInterface::modeRequested, this,
         [this] () {
         //force is true as we must send a new configure response
         updateDecoration(false, true);
     });
 }
 
 bool ShellClient::shouldExposeToWindowManagement()
 {
     if (isInternal()) {
         return false;
     }
     if (isLockScreen()) {
         return false;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     if (m_shellSurface) {
         if (m_shellSurface->isTransient() && !m_shellSurface->acceptsKeyboardFocus()) {
             return false;
         }
     }
     return true;
 }
 
 KWayland::Server::XdgShellSurfaceInterface::States ShellClient::xdgSurfaceStates() const
 {
     XdgShellSurfaceInterface::States states;
     if (isActive()) {
         states |= XdgShellSurfaceInterface::State::Activated;
     }
     if (isFullScreen()) {
         states |= XdgShellSurfaceInterface::State::Fullscreen;
     }
     if (m_requestedMaximizeMode == MaximizeMode::MaximizeFull) {
         states |= XdgShellSurfaceInterface::State::Maximized;
     }
     if (isResize()) {
         states |= XdgShellSurfaceInterface::State::Resizing;
     }
     return states;
 }
 
 void ShellClient::doMinimize()
 {
     if (isMinimized()) {
         workspace()->clientHidden(this);
     } else {
         emit windowShown(this);
     }
     workspace()->updateMinimizedOfTransients(this);
 }
 
 bool ShellClient::setupCompositing()
 {
     if (m_compositingSetup) {
         return true;
     }
     m_compositingSetup = Toplevel::setupCompositing();
     return m_compositingSetup;
 }
 
 void ShellClient::finishCompositing(ReleaseReason releaseReason)
 {
     m_compositingSetup = false;
     Toplevel::finishCompositing(releaseReason);
 }
 
 void ShellClient::placeIn(QRect &area)
 {
     Placement::self()->place(this, area);
     setGeometryRestore(geometry());
 }
 
 void ShellClient::showOnScreenEdge()
 {
     if (!m_plasmaShellSurface || m_unmapped) {
         return;
     }
     hideClient(false);
     workspace()->raiseClient(this);
     if (m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AutoHide) {
         m_plasmaShellSurface->showAutoHidingPanel();
     }
 }
 
 bool ShellClient::dockWantsInput() const
 {
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Panel) {
             return m_plasmaShellSurface->panelTakesFocus();
         }
     }
     return false;
 }
 
 void ShellClient::killWindow()
 {
     if (isInternal()) {
         return;
     }
     if (!surface()) {
         return;
     }
     auto c = surface()->client();
     if (c->processId() == getpid() || c->processId() == 0) {
         c->destroy();
         return;
     }
     ::kill(c->processId(), SIGTERM);
     // give it time to terminate and only if terminate fails, try destroy Wayland connection
     QTimer::singleShot(5000, c, &ClientConnection::destroy);
 }
 
 bool ShellClient::hasPopupGrab() const
 {
     return m_hasPopupGrab;
 }
 
 void ShellClient::popupDone()
 {
     if (m_shellSurface) {
         m_shellSurface->popupDone();
     }
     if (m_xdgShellPopup) {
         m_xdgShellPopup->popupDone();
     }
 }
 
 void ShellClient::updateClientOutputs()
 {
     QVector<OutputInterface*> clientOutputs;
     const auto outputs = waylandServer()->display()->outputs();
     for (OutputInterface* output: qAsConst(outputs)) {
         const QRect outputGeom(output->globalPosition(), output->pixelSize() / output->scale());
         if (geometry().intersects(outputGeom)) {
             clientOutputs << output;
         }
     }
     surface()->setOutputs(clientOutputs);
 }
 
 bool ShellClient::isPopupWindow() const
 {
     if (Toplevel::isPopupWindow()) {
         return true;
     }
     if (isInternal()) {
         return m_internalWindowFlags.testFlag(Qt::Popup);
     }
     if (m_shellSurface != nullptr) {
         return m_shellSurface->isPopup();
     }
     if (m_xdgShellPopup != nullptr) {
         return true;
     }
     return false;
 }
 
 }
diff --git a/shell_client.h b/shell_client.h
index 0198bd89b..4b8655ab1 100644
--- a/shell_client.h
+++ b/shell_client.h
@@ -1,306 +1,303 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 David Edmundson <davidedmundson@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_SHELL_CLIENT_H
 #define KWIN_SHELL_CLIENT_H
 
 #include "abstract_client.h"
 #include <KWayland/Server/xdgshell_interface.h>
 
 namespace KWayland
 {
 namespace Server
 {
 class ShellSurfaceInterface;
 class ServerSideDecorationInterface;
 class ServerSideDecorationPaletteInterface;
 class AppMenuInterface;
 class PlasmaShellSurfaceInterface;
-class QtExtendedSurfaceInterface;
 class XdgDecorationInterface;
 }
 }
 
 namespace KWin
 {
 
 /**
  * @brief The reason for which the server pinged a client surface
  */
 enum class PingReason {
     CloseWindow = 0,
     FocusWindow
 };
 
 class KWIN_EXPORT ShellClient : public AbstractClient
 {
     Q_OBJECT
 public:
     ShellClient(KWayland::Server::ShellSurfaceInterface *surface);
     ShellClient(KWayland::Server::XdgShellSurfaceInterface *surface);
     ShellClient(KWayland::Server::XdgShellPopupInterface *surface);
     virtual ~ShellClient();
 
     bool eventFilter(QObject *watched, QEvent *event) override;
 
     QStringList activities() const override;
     QPoint clientContentPos() const override;
     QSize clientSize() const override;
     QRect transparentRect() const override;
     NET::WindowType windowType(bool direct = false, int supported_types = 0) const override;
     void debug(QDebug &stream) const override;
     double opacity() const override;
     void setOpacity(double opacity) override;
     QByteArray windowRole() const override;
 
     KWayland::Server::ShellSurfaceInterface *shellSurface() const {
         return m_shellSurface;
     }
 
     void blockActivityUpdates(bool b = true) override;
     QString captionNormal() const override {
         return m_caption;
     }
     QString captionSuffix() const override {
         return m_captionSuffix;
     }
     void closeWindow() override;
     AbstractClient *findModal(bool allow_itself = false) override;
     bool isCloseable() const override;
     bool isFullScreen() const override;
     bool isMaximizable() const override;
     bool isMinimizable() const override;
     bool isMovable() const override;
     bool isMovableAcrossScreens() const override;
     bool isResizable() const override;
     bool isShown(bool shaded_is_shown) const override;
     bool isHiddenInternal() const override {
         return m_unmapped || m_hidden;
     }
     void hideClient(bool hide) override;
     MaximizeMode maximizeMode() const override;
     MaximizeMode requestedMaximizeMode() const override;
 
     QRect geometryRestore() const override {
         return m_geomMaximizeRestore;
     }
     bool noBorder() const override;
     void setFullScreen(bool set, bool user = true) override;
     void setNoBorder(bool set) override;
     void updateDecoration(bool check_workspace_pos, bool force = false) override;
     void setOnAllActivities(bool set) override;
     void takeFocus() override;
     bool userCanSetFullScreen() const override;
     bool userCanSetNoBorder() const override;
     bool wantsInput() const override;
     bool dockWantsInput() const override;
     using AbstractClient::resizeWithChecks;
     void resizeWithChecks(int w, int h, ForceGeometry_t force = NormalGeometrySet) override;
     using AbstractClient::setGeometry;
     void setGeometry(int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet) override;
     bool hasStrut() const override;
 
     void setInternalFramebufferObject(const QSharedPointer<QOpenGLFramebufferObject> &fbo) override;
 
     quint32 windowId() const override {
         return m_windowId;
     }
 
     /**
      * The process for this client.
      * Note that processes started by kwin will share its process id.
      * @since 5.11
      * @returns the process if for this client.
      **/
     pid_t pid() const override;
 
     bool isInternal() const;
     bool isLockScreen() const override;
     bool isInputMethod() const override;
     QWindow *internalWindow() const {
         return m_internalWindow;
     }
 
     void installPlasmaShellSurface(KWayland::Server::PlasmaShellSurfaceInterface *surface);
-    void installQtExtendedSurface(KWayland::Server::QtExtendedSurfaceInterface *surface);
     void installServerSideDecoration(KWayland::Server::ServerSideDecorationInterface *decoration);
     void installAppMenu(KWayland::Server::AppMenuInterface *appmenu);
     void installPalette(KWayland::Server::ServerSideDecorationPaletteInterface *palette);
     void installXdgDecoration(KWayland::Server::XdgDecorationInterface *decoration);
 
     bool isInitialPositionSet() const override;
 
     bool isTransient() const override;
     bool hasTransientPlacementHint() const override;
     QRect transientPlacement(const QRect &bounds) const override;
 
     QMatrix4x4 inputTransformation() const override;
 
     bool setupCompositing() override;
     void finishCompositing(ReleaseReason releaseReason = ReleaseReason::Release) override;
 
     void showOnScreenEdge() override;
 
     void killWindow() override;
 
     // TODO: const-ref
     void placeIn(QRect &area);
 
     bool hasPopupGrab() const override;
     void popupDone() override;
 
     void updateColorScheme() override;
 
     bool isPopupWindow() const override;
 
     bool isLocalhost() const override
     {
         return true;
     }
 
 protected:
     void addDamage(const QRegion &damage) override;
     bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const override;
     void doSetActive() override;
     Layer layerForDock() const override;
     void changeMaximize(bool horizontal, bool vertical, bool adjust) override;
     void setGeometryRestore(const QRect &geo) override {
         m_geomMaximizeRestore = geo;
     }
     void doResizeSync() override;
     bool isWaitingForMoveResizeSync() const override;
     bool acceptsFocus() const override;
     void doMinimize() override;
     void doMove(int x, int y) override;
     void updateCaption() override;
 
 private Q_SLOTS:
     void clientFullScreenChanged(bool fullScreen);
 
 private:
     void init();
     template <class T>
     void initSurface(T *shellSurface);
     void requestGeometry(const QRect &rect);
     void doSetGeometry(const QRect &rect);
     void createDecoration(const QRect &oldgeom);
     void destroyClient();
     void unmap();
     void createWindowId();
     void findInternalWindow();
     void updateInternalWindowGeometry();
     void syncGeometryToInternalWindow();
     void updateIcon();
     void markAsMapped();
     void setTransient();
     bool shouldExposeToWindowManagement();
     void updateClientOutputs();
     KWayland::Server::XdgShellSurfaceInterface::States xdgSurfaceStates() const;
     void updateShowOnScreenEdge();
     void updateMaximizeMode(MaximizeMode maximizeMode);
     // called on surface commit and processes all m_pendingConfigureRequests up to m_lastAckedConfigureReqest
     void updatePendingGeometry();
     QPoint popupOffset(const QRect &anchorRect, const Qt::Edges anchorEdge, const Qt::Edges gravity) const;
     static void deleteClient(ShellClient *c);
 
     KWayland::Server::ShellSurfaceInterface *m_shellSurface;
     KWayland::Server::XdgShellSurfaceInterface *m_xdgShellSurface;
     KWayland::Server::XdgShellPopupInterface *m_xdgShellPopup;
 
     // size of the last buffer
     QSize m_clientSize;
     // last size we requested or empty if we haven't sent an explicit request to the client
     // if empty the client should choose their own default size
     QSize m_requestedClientSize = QSize(0, 0);
 
     struct PendingConfigureRequest {
         //note for wl_shell we have no serial, so serialId and m_lastAckedConfigureRequest will always be 0
         //meaning we treat a surface commit as having processed all requests
         quint32 serialId = 0;
         // position to apply after a resize operation has been completed
         QPoint positionAfterResize;
         MaximizeMode maximizeMode;
     };
     QVector<PendingConfigureRequest> m_pendingConfigureRequests;
     quint32 m_lastAckedConfigureRequest = 0;
 
     //mode in use by the current buffer
     MaximizeMode m_maximizeMode = MaximizeRestore;
     //mode we currently want to be, could be pending on client updating, could be not sent yet
     MaximizeMode m_requestedMaximizeMode = MaximizeRestore;
 
     QRect m_geomFsRestore; //size and position of the window before it was set to fullscreen
     bool m_closing = false;
     quint32 m_windowId = 0;
     QWindow *m_internalWindow = nullptr;
     Qt::WindowFlags m_internalWindowFlags = Qt::WindowFlags();
     bool m_unmapped = true;
     QRect m_geomMaximizeRestore; // size and position of the window before it was set to maximize
     NET::WindowType m_windowType = NET::Normal;
     QPointer<KWayland::Server::PlasmaShellSurfaceInterface> m_plasmaShellSurface;
-    QPointer<KWayland::Server::QtExtendedSurfaceInterface> m_qtExtendedSurface;
     QPointer<KWayland::Server::AppMenuInterface> m_appMenuInterface;
     QPointer<KWayland::Server::ServerSideDecorationPaletteInterface> m_paletteInterface;
     KWayland::Server::ServerSideDecorationInterface *m_serverDecoration = nullptr;
     KWayland::Server::XdgDecorationInterface *m_xdgDecoration = nullptr;
     bool m_userNoBorder = false;
     bool m_fullScreen = false;
     bool m_transient = false;
     bool m_hidden = false;
     bool m_internal;
     bool m_hasPopupGrab = false;
     qreal m_opacity = 1.0;
 
     class RequestGeometryBlocker {
     public:
         RequestGeometryBlocker(ShellClient *client)
             : m_client(client)
         {
             m_client->m_requestGeometryBlockCounter++;
         }
         ~RequestGeometryBlocker()
         {
             m_client->m_requestGeometryBlockCounter--;
             if (m_client->m_requestGeometryBlockCounter == 0) {
                 if (m_client->m_blockedRequestGeometry.isValid()) {
                     m_client->requestGeometry(m_client->m_blockedRequestGeometry);
                 } else if (m_client->m_xdgShellSurface) {
                     m_client->m_xdgShellSurface->configure(m_client->xdgSurfaceStates());
                 }
             }
         }
     private:
         ShellClient *m_client;
     };
     friend class RequestGeometryBlocker;
     int m_requestGeometryBlockCounter = 0;
     QRect m_blockedRequestGeometry;
     QString m_caption;
     QString m_captionSuffix;
     QHash<qint32, PingReason> m_pingSerials;
 
     bool m_compositingSetup = false;
 };
 
 }
 
 Q_DECLARE_METATYPE(KWin::ShellClient*)
 
 #endif
diff --git a/wayland_server.cpp b/wayland_server.cpp
index 027898297..f88d98f37 100644
--- a/wayland_server.cpp
+++ b/wayland_server.cpp
@@ -1,824 +1,813 @@
 /********************************************************************
  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 "wayland_server.h"
 #include "client.h"
 #include "platform.h"
 #include "composite.h"
 #include "idle_inhibition.h"
 #include "screens.h"
 #include "shell_client.h"
 #include "workspace.h"
 
 // Client
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 // Server
 #include <KWayland/Server/appmenu_interface.h>
 #include <KWayland/Server/compositor_interface.h>
 #include <KWayland/Server/datadevicemanager_interface.h>
 #include <KWayland/Server/datasource_interface.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/dpms_interface.h>
 #include <KWayland/Server/idle_interface.h>
 #include <KWayland/Server/idleinhibit_interface.h>
 #include <KWayland/Server/output_interface.h>
 #include <KWayland/Server/plasmashell_interface.h>
 #include <KWayland/Server/plasmavirtualdesktop_interface.h>
 #include <KWayland/Server/plasmawindowmanagement_interface.h>
 #include <KWayland/Server/pointerconstraints_interface.h>
 #include <KWayland/Server/pointergestures_interface.h>
 #include <KWayland/Server/qtsurfaceextension_interface.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/server_decoration_interface.h>
 #include <KWayland/Server/server_decoration_palette_interface.h>
 #include <KWayland/Server/shadow_interface.h>
 #include <KWayland/Server/subcompositor_interface.h>
 #include <KWayland/Server/blur_interface.h>
 #include <KWayland/Server/shell_interface.h>
 #include <KWayland/Server/outputmanagement_interface.h>
 #include <KWayland/Server/outputconfiguration_interface.h>
 #include <KWayland/Server/xdgdecoration_interface.h>
 #include <KWayland/Server/xdgshell_interface.h>
 #include <KWayland/Server/xdgforeign_interface.h>
 #include <KWayland/Server/xdgoutput_interface.h>
 
 
 // Qt
 #include <QDir>
 #include <QFileInfo>
 #include <QThread>
 #include <QWindow>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 using namespace KWayland::Server;
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(WaylandServer)
 
 WaylandServer::WaylandServer(QObject *parent)
     : QObject(parent)
 {
     qRegisterMetaType<KWayland::Server::OutputInterface::DpmsMode>();
 
     connect(kwinApp(), &Application::screensCreated, this, &WaylandServer::initOutputs);
     connect(kwinApp(), &Application::x11ConnectionChanged, this, &WaylandServer::setupX11ClipboardSync);
 }
 
 WaylandServer::~WaylandServer()
 {
     destroyInputMethodConnection();
 }
 
 void WaylandServer::destroyInternalConnection()
 {
     emit terminatingInternalClientConnection();
     if (m_internalConnection.client) {
         // delete all connections hold by plugins like e.g. widget style
         const auto connections = KWayland::Client::ConnectionThread::connections();
         for (auto c : connections) {
             if (c == m_internalConnection.client) {
                 continue;
             }
             emit c->connectionDied();
         }
 
         delete m_internalConnection.registry;
         delete m_internalConnection.shm;
         dispatch();
         m_internalConnection.client->deleteLater();
         m_internalConnection.clientThread->quit();
         m_internalConnection.clientThread->wait();
         delete m_internalConnection.clientThread;
         m_internalConnection.client = nullptr;
         m_internalConnection.server->destroy();
         m_internalConnection.server = nullptr;
     }
 }
 
 void WaylandServer::terminateClientConnections()
 {
     destroyInternalConnection();
     destroyInputMethodConnection();
     if (m_display) {
         const auto connections = m_display->connections();
         for (auto it = connections.begin(); it != connections.end(); ++it) {
             (*it)->destroy();
         }
     }
 }
 
 template <class T>
 void WaylandServer::createSurface(T *surface)
 {
     if (!Workspace::self()) {
         // it's possible that a Surface gets created before Workspace is created
         return;
     }
     if (surface->client() == m_xwayland.client) {
         // skip Xwayland clients, those are created using standard X11 way
         return;
     }
     if (surface->client() == m_screenLockerClientConnection) {
         ScreenLocker::KSldApp::self()->lockScreenShown();
     }
     auto client = new ShellClient(surface);
     if (ServerSideDecorationInterface *deco = ServerSideDecorationInterface::get(surface->surface())) {
         client->installServerSideDecoration(deco);
     }
     auto it = std::find_if(m_plasmaShellSurfaces.begin(), m_plasmaShellSurfaces.end(),
         [client] (PlasmaShellSurfaceInterface *surface) {
             return client->surface() == surface->surface();
         }
     );
     if (it != m_plasmaShellSurfaces.end()) {
         client->installPlasmaShellSurface(*it);
         m_plasmaShellSurfaces.erase(it);
     }
     if (auto menu = m_appMenuManager->appMenuForSurface(surface->surface())) {
         client->installAppMenu(menu);
     }
     if (auto palette = m_paletteManager->paletteForSurface(surface->surface())) {
         client->installPalette(palette);
     }
     if (client->isInternal()) {
         m_internalClients << client;
     } else {
         m_clients << client;
     }
     if (client->readyForPainting()) {
         emit shellClientAdded(client);
     } else {
         connect(client, &ShellClient::windowShown, this, &WaylandServer::shellClientShown);
     }
 
     //not directly connected as the connection is tied to client instead of this
     connect(m_XdgForeign, &KWayland::Server::XdgForeignInterface::transientChanged, client, [this](KWayland::Server::SurfaceInterface *child) {
         emit foreignTransientChanged(child);
     });
 }
 
 bool WaylandServer::init(const QByteArray &socketName, InitalizationFlags flags)
 {
     m_initFlags = flags;
     m_display = new KWayland::Server::Display(this);
     if (!socketName.isNull() && !socketName.isEmpty()) {
         m_display->setSocketName(QString::fromUtf8(socketName));
     } else {
         m_display->setAutomaticSocketNaming(true);
     }
     m_display->start();
     if (!m_display->isRunning()) {
         return false;
     }
     m_compositor = m_display->createCompositor(m_display);
     m_compositor->create();
     connect(m_compositor, &CompositorInterface::surfaceCreated, this,
         [this] (SurfaceInterface *surface) {
             // check whether we have a Toplevel with the Surface's id
             Workspace *ws = Workspace::self();
             if (!ws) {
                 // it's possible that a Surface gets created before Workspace is created
                 return;
             }
             if (surface->client() != xWaylandConnection()) {
                 // setting surface is only relevat for Xwayland clients
                 return;
             }
             auto check = [surface] (const Toplevel *t) {
                 return t->surfaceId() == surface->id();
             };
             if (Toplevel *t = ws->findToplevel(check)) {
                 t->setSurface(surface);
             }
         }
     );
     m_shell = m_display->createShell(m_display);
     m_shell->create();
     connect(m_shell, &ShellInterface::surfaceCreated, this, &WaylandServer::createSurface<ShellSurfaceInterface>);
 
     m_xdgShell5 = m_display->createXdgShell(XdgShellInterfaceVersion::UnstableV5, m_display);
     m_xdgShell5->create();
     connect(m_xdgShell5, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
     // TODO: verify seat and serial
     connect(m_xdgShell5, &XdgShellInterface::popupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
 
     m_xdgShell6 = m_display->createXdgShell(XdgShellInterfaceVersion::UnstableV6, m_display);
     m_xdgShell6->create();
     connect(m_xdgShell6, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
     connect(m_xdgShell6, &XdgShellInterface::xdgPopupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
 
     m_xdgShell = m_display->createXdgShell(XdgShellInterfaceVersion::Stable, m_display);
     m_xdgShell->create();
     connect(m_xdgShell, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
     connect(m_xdgShell, &XdgShellInterface::xdgPopupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
 
     m_xdgDecorationManager = m_display->createXdgDecorationManager(m_xdgShell, m_display);
     m_xdgDecorationManager->create();
     connect(m_xdgDecorationManager, &XdgDecorationManagerInterface::xdgDecorationInterfaceCreated, this,  [this] (XdgDecorationInterface *deco) {
         if (ShellClient *client = findClient(deco->surface()->surface())) {
             client->installXdgDecoration(deco);
         }
     });
 
     m_display->createShm();
     m_seat = m_display->createSeat(m_display);
     m_seat->create();
     m_display->createPointerGestures(PointerGesturesInterfaceVersion::UnstableV1, m_display)->create();
     m_display->createPointerConstraints(PointerConstraintsInterfaceVersion::UnstableV1, m_display)->create();
     auto ddm = m_display->createDataDeviceManager(m_display);
     ddm->create();
     connect(ddm, &DataDeviceManagerInterface::dataDeviceCreated, this,
         [this] (DataDeviceInterface *ddi) {
             if (ddi->client() == m_xclipbaordSync.client && m_xclipbaordSync.client != nullptr) {
                 m_xclipbaordSync.ddi = QPointer<DataDeviceInterface>(ddi);
                 emit xclipboardSyncDataDeviceCreated();
                 connect(m_xclipbaordSync.ddi.data(), &DataDeviceInterface::selectionChanged, this,
                     [this] {
                         // testing whether the active client inherits Client
                         // it would be better to test for the keyboard focus, but we might get a clipboard update
                         // when the Client is already active, but no Surface is created yet.
                         if (workspace()->activeClient() && workspace()->activeClient()->inherits("KWin::Client")) {
                             m_seat->setSelection(m_xclipbaordSync.ddi.data());
                         }
                     }
                 );
             }
         }
     );
     m_idle = m_display->createIdle(m_display);
     m_idle->create();
     auto idleInhibition = new IdleInhibition(m_idle);
     connect(this, &WaylandServer::shellClientAdded, idleInhibition, &IdleInhibition::registerShellClient);
     m_display->createIdleInhibitManager(IdleInhibitManagerInterfaceVersion::UnstableV1, m_display)->create();
     m_plasmaShell = m_display->createPlasmaShell(m_display);
     m_plasmaShell->create();
     connect(m_plasmaShell, &PlasmaShellInterface::surfaceCreated,
         [this] (PlasmaShellSurfaceInterface *surface) {
             if (ShellClient *client = findClient(surface->surface())) {
                 client->installPlasmaShellSurface(surface);
             } else {
                 m_plasmaShellSurfaces << surface;
                 connect(surface, &QObject::destroyed, this,
                     [this, surface] {
                         m_plasmaShellSurfaces.removeOne(surface);
                     }
                 );
             }
         }
     );
-
-
-    m_qtExtendedSurface = m_display->createQtSurfaceExtension(m_display);
-    m_qtExtendedSurface->create();
-    connect(m_qtExtendedSurface, &QtSurfaceExtensionInterface::surfaceCreated,
-        [this] (QtExtendedSurfaceInterface *surface) {
-            if (ShellClient *client = findClient(surface->surface())) {
-                client->installQtExtendedSurface(surface);
-            }
-        }
-    );
     m_appMenuManager = m_display->createAppMenuManagerInterface(m_display);
     m_appMenuManager->create();
     connect(m_appMenuManager, &AppMenuManagerInterface::appMenuCreated,
         [this] (AppMenuInterface *appMenu) {
             if (ShellClient *client = findClient(appMenu->surface())) {
                 client->installAppMenu(appMenu);
             }
         }
     );
     m_paletteManager = m_display->createServerSideDecorationPaletteManager(m_display);
     m_paletteManager->create();
     connect(m_paletteManager, &ServerSideDecorationPaletteManagerInterface::paletteCreated,
         [this] (ServerSideDecorationPaletteInterface *palette) {
             if (ShellClient *client = findClient(palette->surface())) {
                 client->installPalette(palette);
             }
         }
     );
 
     m_windowManagement = m_display->createPlasmaWindowManagement(m_display);
     m_windowManagement->create();
     m_windowManagement->setShowingDesktopState(PlasmaWindowManagementInterface::ShowingDesktopState::Disabled);
     connect(m_windowManagement, &PlasmaWindowManagementInterface::requestChangeShowingDesktop, this,
         [] (PlasmaWindowManagementInterface::ShowingDesktopState state) {
             if (!workspace()) {
                 return;
             }
             bool set = false;
             switch (state) {
             case PlasmaWindowManagementInterface::ShowingDesktopState::Disabled:
                 set = false;
                 break;
             case PlasmaWindowManagementInterface::ShowingDesktopState::Enabled:
                 set = true;
                 break;
             default:
                 Q_UNREACHABLE();
                 break;
             }
             if (set == workspace()->showingDesktop()) {
                 return;
             }
             workspace()->setShowingDesktop(set);
         }
     );
 
 
     m_virtualDesktopManagement = m_display->createPlasmaVirtualDesktopManagement(m_display);
     m_virtualDesktopManagement->create();
     m_windowManagement->setPlasmaVirtualDesktopManagementInterface(m_virtualDesktopManagement);
 
     auto shadowManager = m_display->createShadowManager(m_display);
     shadowManager->create();
 
     m_display->createDpmsManager(m_display)->create();
 
     m_decorationManager = m_display->createServerSideDecorationManager(m_display);
     connect(m_decorationManager, &ServerSideDecorationManagerInterface::decorationCreated, this,
         [this] (ServerSideDecorationInterface *deco) {
             if (ShellClient *c = findClient(deco->surface())) {
                 c->installServerSideDecoration(deco);
             }
             connect(deco, &ServerSideDecorationInterface::modeRequested, this,
                 [this, deco] (ServerSideDecorationManagerInterface::Mode mode) {
                     // always acknowledge the requested mode
                     deco->setMode(mode);
                 }
             );
         }
     );
     m_decorationManager->create();
 
     m_outputManagement = m_display->createOutputManagement(m_display);
     connect(m_outputManagement, &OutputManagementInterface::configurationChangeRequested,
             this, [this](KWayland::Server::OutputConfigurationInterface *config) {
                 kwinApp()->platform()->configurationChangeRequested(config);
     });
     m_outputManagement->create();
 
     m_xdgOutputManager = m_display->createXdgOutputManager(m_display);
     m_xdgOutputManager->create();
 
     m_display->createSubCompositor(m_display)->create();
 
     m_XdgForeign = m_display->createXdgForeignInterface(m_display);
     m_XdgForeign->create();
 
     return true;
 }
 
 SurfaceInterface *WaylandServer::findForeignTransientForSurface(SurfaceInterface *surface)
 {
     return m_XdgForeign->transientFor(surface);
 }
 
 void WaylandServer::shellClientShown(Toplevel *t)
 {
     ShellClient *c = dynamic_cast<ShellClient*>(t);
     if (!c) {
         qCWarning(KWIN_CORE) << "Failed to cast a Toplevel which is supposed to be a ShellClient to ShellClient";
         return;
     }
     disconnect(c, &ShellClient::windowShown, this, &WaylandServer::shellClientShown);
     emit shellClientAdded(c);
 }
 
 void WaylandServer::initWorkspace()
 {
     VirtualDesktopManager::self()->setVirtualDesktopManagement(m_virtualDesktopManagement);
 
     if (m_windowManagement) {
         connect(workspace(), &Workspace::showingDesktopChanged, this,
             [this] (bool set) {
                 using namespace KWayland::Server;
                 m_windowManagement->setShowingDesktopState(set ?
                     PlasmaWindowManagementInterface::ShowingDesktopState::Enabled :
                     PlasmaWindowManagementInterface::ShowingDesktopState::Disabled
                 );
             }
         );
     }
 
     if (hasScreenLockerIntegration()) {
         if (m_internalConnection.interfacesAnnounced) {
             initScreenLocker();
         } else {
             connect(m_internalConnection.registry, &KWayland::Client::Registry::interfacesAnnounced, this, &WaylandServer::initScreenLocker);
         }
     } else {
         emit initialized();
     }
 }
 
 void WaylandServer::initScreenLocker()
 {
     ScreenLocker::KSldApp::self();
     ScreenLocker::KSldApp::self()->setWaylandDisplay(m_display);
     ScreenLocker::KSldApp::self()->setGreeterEnvironment(kwinApp()->processStartupEnvironment());
     ScreenLocker::KSldApp::self()->initialize();
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::greeterClientConnectionChanged, this,
         [this] () {
             m_screenLockerClientConnection = ScreenLocker::KSldApp::self()->greeterClientConnection();
         }
     );
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::unlocked, this,
         [this] () {
             m_screenLockerClientConnection = nullptr;
         }
     );
 
     if (m_initFlags.testFlag(InitalizationFlag::LockScreen)) {
         ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     }
     emit initialized();
 }
 
 void WaylandServer::initOutputs()
 {
     if (kwinApp()->platform()->handlesOutputs()) {
         return;
     }
     syncOutputsToWayland();
     connect(screens(), &Screens::changed, this,
         [this] {
             // when screens change we need to sync this to Wayland.
             // Unfortunately we don't have much information and cannot properly match a KWin screen
             // to a Wayland screen.
             // Thus we just recreate all outputs and delete the old ones
             const auto outputs = m_display->outputs();
             syncOutputsToWayland();
             qDeleteAll(outputs);
         }
     );
 }
 
 void WaylandServer::syncOutputsToWayland()
 {
     Screens *s = screens();
     Q_ASSERT(s);
     for (int i = 0; i < s->count(); ++i) {
         OutputInterface *output = m_display->createOutput(m_display);
         auto xdgOutput = xdgOutputManager()->createXdgOutput(output, output);
 
         output->setScale(s->scale(i));
         const QRect &geo = s->geometry(i);
         output->setGlobalPosition(geo.topLeft());
         output->setPhysicalSize(s->physicalSize(i).toSize());
         output->addMode(geo.size());
 
         xdgOutput->setLogicalPosition(geo.topLeft());
         xdgOutput->setLogicalSize(geo.size());
         xdgOutput->done();
 
         output->create();
     }
 }
 
 WaylandServer::SocketPairConnection WaylandServer::createConnection()
 {
     SocketPairConnection ret;
     int sx[2];
     if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) < 0) {
         qCWarning(KWIN_CORE) << "Could not create socket";
         return ret;
     }
     ret.connection = m_display->createClient(sx[0]);
     ret.fd = sx[1];
     return ret;
 }
 
 int WaylandServer::createXWaylandConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_xwayland.client = socket.connection;
     m_xwayland.destroyConnection = connect(m_xwayland.client, &KWayland::Server::ClientConnection::disconnected, this,
         [] {
             qFatal("Xwayland Connection died");
         }
     );
     return socket.fd;
 }
 
 void WaylandServer::destroyXWaylandConnection()
 {
     if (!m_xwayland.client) {
         return;
     }
     // first terminate the clipboard sync
     if (m_xclipbaordSync.process) {
         m_xclipbaordSync.process->terminate();
     }
     disconnect(m_xwayland.destroyConnection);
     m_xwayland.client->destroy();
     m_xwayland.client = nullptr;
 }
 
 int WaylandServer::createInputMethodConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_inputMethodServerConnection = socket.connection;
     return socket.fd;
 }
 
 void WaylandServer::destroyInputMethodConnection()
 {
     if (!m_inputMethodServerConnection) {
         return;
     }
     m_inputMethodServerConnection->destroy();
     m_inputMethodServerConnection = nullptr;
 }
 
 int WaylandServer::createXclipboardSyncConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_xclipbaordSync.client = socket.connection;
     return socket.fd;
 }
 
 void WaylandServer::setupX11ClipboardSync()
 {
     if (m_xclipbaordSync.process) {
         qCWarning(KWIN_CORE) << "Tried to start x clipboard syncer although process already started";
         return;
     }
 
     int socket = dup(createXclipboardSyncConnection());
     if (socket == -1) {
         delete m_xclipbaordSync.client;
         m_xclipbaordSync.client = nullptr;
         qCWarning(KWIN_CORE) << "Could not create wayland socket for x clipboard syncer";
         return;
     }
     if (socket >= 0) {
         QProcessEnvironment environment = kwinApp()->processStartupEnvironment();
         environment.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
         environment.insert(QStringLiteral("DISPLAY"), QString::fromUtf8(qgetenv("DISPLAY")));
         environment.remove("WAYLAND_DISPLAY");
         m_xclipbaordSync.process = new Process(this);
         m_xclipbaordSync.process->setProcessChannelMode(QProcess::ForwardedChannels);
         auto finishedSignal = static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished);
         connect(m_xclipbaordSync.process, finishedSignal, this,
             [this] {
                 qCDebug(KWIN_CORE) << "X clipboard syncer process finished";
                 m_xclipbaordSync.process->deleteLater();
                 m_xclipbaordSync.process = nullptr;
                 m_xclipbaordSync.ddi.clear();
                 m_xclipbaordSync.client->destroy();
                 m_xclipbaordSync.client = nullptr;
                 // TODO: restart
             }
         );
         m_xclipbaordSync.process->setProcessEnvironment(environment);
         // start from build directory if executable is available there (e.g. autotests), otherwise start libexec executable
         const QFileInfo clipboardSync{QDir{QCoreApplication::applicationDirPath()}, QStringLiteral("org_kde_kwin_xclipboard_syncer")};
         if (clipboardSync.exists()) {
             qCDebug(KWIN_CORE) << "Starting" << clipboardSync.absoluteFilePath();
             m_xclipbaordSync.process->start(clipboardSync.absoluteFilePath());
         } else {
             qCDebug(KWIN_CORE) << "Starting" << KWIN_XCLIPBOARD_SYNC_BIN;
             m_xclipbaordSync.process->start(QStringLiteral(KWIN_XCLIPBOARD_SYNC_BIN));
         }
     }
 }
 
 void WaylandServer::createInternalConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return;
     }
     m_internalConnection.server = socket.connection;
     using namespace KWayland::Client;
     m_internalConnection.client = new ConnectionThread();
     m_internalConnection.client->setSocketFd(socket.fd);
     m_internalConnection.clientThread = new QThread;
     m_internalConnection.client->moveToThread(m_internalConnection.clientThread);
     m_internalConnection.clientThread->start();
 
     connect(m_internalConnection.client, &ConnectionThread::connected, this,
         [this] {
             Registry *registry = new Registry(this);
             EventQueue *eventQueue = new EventQueue(this);
             eventQueue->setup(m_internalConnection.client);
             registry->setEventQueue(eventQueue);
             registry->create(m_internalConnection.client);
             m_internalConnection.registry = registry;
             connect(registry, &Registry::shmAnnounced, this,
                 [this] (quint32 name, quint32 version) {
                     m_internalConnection.shm = m_internalConnection.registry->createShmPool(name, version, this);
                 }
             );
             connect(registry, &Registry::interfacesAnnounced, this,
                 [this] {
                     m_internalConnection.interfacesAnnounced = true;
                 }
             );
             registry->setup();
         }
     );
     m_internalConnection.client->initConnection();
 }
 
 void WaylandServer::removeClient(ShellClient *c)
 {
     m_clients.removeAll(c);
     m_internalClients.removeAll(c);
     emit shellClientRemoved(c);
 }
 
 void WaylandServer::dispatch()
 {
     if (!m_display) {
         return;
     }
     if (m_internalConnection.server) {
         m_internalConnection.server->flush();
     }
     m_display->dispatchEvents(0);
 }
 
 static ShellClient *findClientInList(const QList<ShellClient*> &clients, quint32 id)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [id] (ShellClient *c) {
             return c->windowId() == id;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
 static ShellClient *findClientInList(const QList<ShellClient*> &clients, KWayland::Server::SurfaceInterface *surface)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [surface] (ShellClient *c) {
             return c->surface() == surface;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
 ShellClient *WaylandServer::findClient(quint32 id) const
 {
     if (id == 0) {
         return nullptr;
     }
     if (ShellClient *c = findClientInList(m_clients, id)) {
         return c;
     }
     if (ShellClient *c = findClientInList(m_internalClients, id)) {
         return c;
     }
     return nullptr;
 }
 
 ShellClient *WaylandServer::findClient(SurfaceInterface *surface) const
 {
     if (!surface) {
         return nullptr;
     }
     if (ShellClient *c = findClientInList(m_clients, surface)) {
         return c;
     }
     if (ShellClient *c = findClientInList(m_internalClients, surface)) {
         return c;
     }
     return nullptr;
 }
 
 AbstractClient *WaylandServer::findAbstractClient(SurfaceInterface *surface) const
 {
     return findClient(surface);
 }
 
 ShellClient *WaylandServer::findClient(QWindow *w) const
 {
     if (!w) {
         return nullptr;
     }
     auto it = std::find_if(m_internalClients.constBegin(), m_internalClients.constEnd(),
         [w] (const ShellClient *c) {
             return c->internalWindow() == w;
         }
     );
     if (it != m_internalClients.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 quint32 WaylandServer::createWindowId(SurfaceInterface *surface)
 {
     auto it = m_clientIds.constFind(surface->client());
     quint16 clientId = 0;
     if (it != m_clientIds.constEnd()) {
         clientId = it.value();
     } else {
         clientId = createClientId(surface->client());
     }
     Q_ASSERT(clientId != 0);
     quint32 id = clientId;
     // TODO: this does not prevent that two surfaces of same client get same id
     id = (id << 16) | (surface->id() & 0xFFFF);
     if (findClient(id)) {
         qCWarning(KWIN_CORE) << "Invalid client windowId generated:" << id;
         return 0;
     }
     return id;
 }
 
 quint16 WaylandServer::createClientId(ClientConnection *c)
 {
     auto ids = m_clientIds.values().toSet();
     quint16 id = 1;
     if (!ids.isEmpty()) {
         for (quint16 i = ids.count() + 1; i >= 1 ; i--) {
             if (!ids.contains(i)) {
                 id = i;
                 break;
             }
         }
     }
     Q_ASSERT(!ids.contains(id));
     m_clientIds.insert(c, id);
     connect(c, &ClientConnection::disconnected, this,
         [this] (ClientConnection *c) {
             m_clientIds.remove(c);
         }
     );
     return id;
 }
 
 bool WaylandServer::isScreenLocked() const
 {
     if (!hasScreenLockerIntegration()) {
         return false;
     }
     return ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::Locked ||
            ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::AcquiringLock;
 }
 
 bool WaylandServer::hasScreenLockerIntegration() const
 {
     return !m_initFlags.testFlag(InitalizationFlag::NoLockScreenIntegration);
 }
 
 bool WaylandServer::hasGlobalShortcutSupport() const
 {
     return !m_initFlags.testFlag(InitalizationFlag::NoGlobalShortcuts);
 }
 
 void WaylandServer::simulateUserActivity()
 {
     if (m_idle) {
         m_idle->simulateUserActivity();
     }
 }
 
 }
diff --git a/wayland_server.h b/wayland_server.h
index 3fc943ee4..cb79b6f09 100644
--- a/wayland_server.h
+++ b/wayland_server.h
@@ -1,288 +1,287 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_WAYLAND_SERVER_H
 #define KWIN_WAYLAND_SERVER_H
 
 #include <kwinglobals.h>
 
 #include <QObject>
 #include <QPointer>
 
 class QThread;
 class QProcess;
 class QWindow;
 
 namespace KWayland
 {
 namespace Client
 {
 class ConnectionThread;
 class Registry;
 class ShmPool;
 class Surface;
 }
 namespace Server
 {
 class AppMenuManagerInterface;
 class ClientConnection;
 class CompositorInterface;
 class Display;
 class DataDeviceInterface;
 class IdleInterface;
 class ShellInterface;
 class SeatInterface;
 class ServerSideDecorationManagerInterface;
 class ServerSideDecorationPaletteManagerInterface;
 class SurfaceInterface;
 class OutputInterface;
 class PlasmaShellInterface;
 class PlasmaShellSurfaceInterface;
 class PlasmaVirtualDesktopManagementInterface;
 class PlasmaWindowManagementInterface;
 class QtSurfaceExtensionInterface;
 class OutputManagementInterface;
 class OutputConfigurationInterface;
 class XdgDecorationManagerInterface;
 class XdgShellInterface;
 class XdgForeignInterface;
 class XdgOutputManagerInterface;
 }
 }
 
 namespace KWin
 {
 class ShellClient;
 
 class AbstractClient;
 class Toplevel;
 
 class KWIN_EXPORT WaylandServer : public QObject
 {
     Q_OBJECT
 public:
     enum class InitalizationFlag {
         NoOptions = 0x0,
         LockScreen = 0x1,
         NoLockScreenIntegration = 0x2,
         NoGlobalShortcuts = 0x4
     };
 
     Q_DECLARE_FLAGS(InitalizationFlags, InitalizationFlag)
 
     virtual ~WaylandServer();
     bool init(const QByteArray &socketName = QByteArray(), InitalizationFlags flags = InitalizationFlag::NoOptions);
     void terminateClientConnections();
 
     KWayland::Server::Display *display() {
         return m_display;
     }
     KWayland::Server::CompositorInterface *compositor() {
         return m_compositor;
     }
     KWayland::Server::SeatInterface *seat() {
         return m_seat;
     }
     KWayland::Server::ShellInterface *shell() {
         return m_shell;
     }
     KWayland::Server::PlasmaVirtualDesktopManagementInterface *virtualDesktopManagement() {
         return m_virtualDesktopManagement;
     }
     KWayland::Server::PlasmaWindowManagementInterface *windowManagement() {
         return m_windowManagement;
     }
     KWayland::Server::ServerSideDecorationManagerInterface *decorationManager() const {
         return m_decorationManager;
     }
     KWayland::Server::XdgOutputManagerInterface *xdgOutputManager() const {
         return m_xdgOutputManager;
     }
 
     QList<ShellClient*> clients() const {
         return m_clients;
     }
     QList<ShellClient*> internalClients() const {
         return m_internalClients;
     }
     void removeClient(ShellClient *c);
     ShellClient *findClient(quint32 id) const;
     ShellClient *findClient(KWayland::Server::SurfaceInterface *surface) const;
     AbstractClient *findAbstractClient(KWayland::Server::SurfaceInterface *surface) const;
     ShellClient *findClient(QWindow *w) const;
 
     /**
      * return a transient parent of a surface imported with the foreign protocol, if any
      */
     KWayland::Server::SurfaceInterface *findForeignTransientForSurface(KWayland::Server::SurfaceInterface *surface);
 
     /**
      * @returns file descriptor for Xwayland to connect to.
      **/
     int createXWaylandConnection();
     void destroyXWaylandConnection();
 
     /**
      * @returns file descriptor to the input method server's socket.
      **/
     int createInputMethodConnection();
     void destroyInputMethodConnection();
 
     int createXclipboardSyncConnection();
 
     /**
      * @returns true if screen is locked.
      **/
     bool isScreenLocked() const;
     /**
      * @returns whether integration with KScreenLocker is available.
      **/
     bool hasScreenLockerIntegration() const;
 
     /**
      * @returns whether any kind of global shortcuts are supported.
      **/
     bool hasGlobalShortcutSupport() const;
 
     void createInternalConnection();
     void initWorkspace();
 
     KWayland::Server::ClientConnection *xWaylandConnection() const {
         return m_xwayland.client;
     }
     KWayland::Server::ClientConnection *inputMethodConnection() const {
         return m_inputMethodServerConnection;
     }
     KWayland::Server::ClientConnection *internalConnection() const {
         return m_internalConnection.server;
     }
     KWayland::Server::ClientConnection *screenLockerClientConnection() const {
         return m_screenLockerClientConnection;
     }
     QPointer<KWayland::Server::DataDeviceInterface> xclipboardSyncDataDevice() const {
         return m_xclipbaordSync.ddi;
     }
     KWayland::Client::ShmPool *internalShmPool() {
         return m_internalConnection.shm;
     }
     KWayland::Client::ConnectionThread *internalClientConection() {
         return m_internalConnection.client;
     }
     KWayland::Client::Registry *internalClientRegistry() {
         return m_internalConnection.registry;
     }
     void dispatch();
     quint32 createWindowId(KWayland::Server::SurfaceInterface *surface);
 
     /**
      * Struct containing information for a created Wayland connection through a
      * socketpair.
      **/
     struct SocketPairConnection {
         /**
          * ServerSide Connection
          **/
         KWayland::Server::ClientConnection *connection = nullptr;
         /**
          * client-side file descriptor for the socket
          **/
         int fd = -1;
     };
     /**
      * Creates a Wayland connection using a socket pair.
      **/
     SocketPairConnection createConnection();
 
     void simulateUserActivity();
 
 Q_SIGNALS:
     void shellClientAdded(KWin::ShellClient*);
     void shellClientRemoved(KWin::ShellClient*);
     void terminatingInternalClientConnection();
     void initialized();
     void foreignTransientChanged(KWayland::Server::SurfaceInterface *child);
     void xclipboardSyncDataDeviceCreated();
 
 private:
     void setupX11ClipboardSync();
     void shellClientShown(Toplevel *t);
     void initOutputs();
     void syncOutputsToWayland();
     quint16 createClientId(KWayland::Server::ClientConnection *c);
     void destroyInternalConnection();
     void configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config);
     template <class T>
     void createSurface(T *surface);
     void initScreenLocker();
     KWayland::Server::Display *m_display = nullptr;
     KWayland::Server::CompositorInterface *m_compositor = nullptr;
     KWayland::Server::SeatInterface *m_seat = nullptr;
     KWayland::Server::ShellInterface *m_shell = nullptr;
     KWayland::Server::XdgShellInterface *m_xdgShell5 = nullptr;
     KWayland::Server::XdgShellInterface *m_xdgShell6 = nullptr;
     KWayland::Server::XdgShellInterface *m_xdgShell = nullptr;
     KWayland::Server::PlasmaShellInterface *m_plasmaShell = nullptr;
     KWayland::Server::PlasmaWindowManagementInterface *m_windowManagement = nullptr;
     KWayland::Server::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
-    KWayland::Server::QtSurfaceExtensionInterface *m_qtExtendedSurface = nullptr;
     KWayland::Server::ServerSideDecorationManagerInterface *m_decorationManager = nullptr;
     KWayland::Server::OutputManagementInterface *m_outputManagement = nullptr;
     KWayland::Server::AppMenuManagerInterface *m_appMenuManager = nullptr;
     KWayland::Server::ServerSideDecorationPaletteManagerInterface *m_paletteManager = nullptr;
     KWayland::Server::IdleInterface *m_idle = nullptr;
     KWayland::Server::XdgOutputManagerInterface *m_xdgOutputManager = nullptr;
     KWayland::Server::XdgDecorationManagerInterface *m_xdgDecorationManager = nullptr;
     struct {
         KWayland::Server::ClientConnection *client = nullptr;
         QMetaObject::Connection destroyConnection;
     } m_xwayland;
     KWayland::Server::ClientConnection *m_inputMethodServerConnection = nullptr;
     KWayland::Server::ClientConnection *m_screenLockerClientConnection = nullptr;
     struct {
         KWayland::Server::ClientConnection *server = nullptr;
         KWayland::Client::ConnectionThread *client = nullptr;
         QThread *clientThread = nullptr;
         KWayland::Client::Registry *registry = nullptr;
         KWayland::Client::ShmPool *shm = nullptr;
         bool interfacesAnnounced = false;
 
     } m_internalConnection;
     struct {
         QProcess *process = nullptr;
         KWayland::Server::ClientConnection *client = nullptr;
         QPointer<KWayland::Server::DataDeviceInterface> ddi;
     } m_xclipbaordSync;
     KWayland::Server::XdgForeignInterface *m_XdgForeign = nullptr;
     QList<ShellClient*> m_clients;
     QList<ShellClient*> m_internalClients;
     QHash<KWayland::Server::ClientConnection*, quint16> m_clientIds;
     InitalizationFlags m_initFlags;
     QVector<KWayland::Server::PlasmaShellSurfaceInterface*> m_plasmaShellSurfaces;
     KWIN_SINGLETON(WaylandServer)
 };
 
 inline
 WaylandServer *waylandServer() {
     return WaylandServer::self();
 }
 
 } // namespace KWin
 
 #endif