diff --git a/abstract_client.cpp b/abstract_client.cpp
index db76e4558..cdfcc728c 100644
--- a/abstract_client.cpp
+++ b/abstract_client.cpp
@@ -1,3265 +1,3273 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "abstract_client.h"
 
 #include "appmenu.h"
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationpalette.h"
 #include "decorations/decorationbridge.h"
 #include "cursor.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "outline.h"
 #include "screens.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "useractions.h"
 #include "workspace.h"
 
 #include "wayland_server.h"
 #include <KWayland/Server/plasmawindowmanagement_interface.h>
 
 #include <KDecoration2/Decoration>
 
 #include <KDesktopFile>
 
 #include <QMouseEvent>
 #include <QStyleHints>
 
 namespace KWin
 {
 
 static inline int sign(int v)
 {
     return (v > 0) - (v < 0);
 }
 
 QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> AbstractClient::s_palettes;
 std::shared_ptr<Decoration::DecorationPalette> AbstractClient::s_defaultPalette;
 
 AbstractClient::AbstractClient()
     : Toplevel()
 #ifdef KWIN_BUILD_TABBOX
     , m_tabBoxClient(QSharedPointer<TabBox::TabBoxClientImpl>(new TabBox::TabBoxClientImpl(this)))
 #endif
     , m_colorScheme(QStringLiteral("kdeglobals"))
 {
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::removeCheckScreenConnection);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::setupCheckScreenConnection);
 
     connect(this, &AbstractClient::paletteChanged, this, &AbstractClient::triggerDecorationRepaint);
 
     connect(Decoration::DecorationBridge::self(), &QObject::destroyed, this, &AbstractClient::destroyDecoration);
 
     // If the user manually moved the window, don't restore it after the keyboard closes
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged), this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, &AbstractClient::fullScreenChanged, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
 
     // replace on-screen-display on size changes
     connect(this, &AbstractClient::frameGeometryChanged, this,
         [this] (Toplevel *c, const QRect &old) {
             Q_UNUSED(c)
             if (isOnScreenDisplay() && !frameGeometry().isEmpty() && old.size() != frameGeometry().size() && !isInitialPositionSet()) {
                 GeometryUpdatesBlocker blocker(this);
                 const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
                 Placement::self()->place(this, area);
                 setGeometryRestore(frameGeometry());
             }
         }
     );
 
     connect(this, &AbstractClient::paddingChanged, this, [this]() {
         m_visibleRectBeforeGeometryUpdate = visibleRect();
     });
 
     connect(ApplicationMenu::self(), &ApplicationMenu::applicationMenuEnabledChanged, this, [this] {
         emit hasApplicationMenuChanged(hasApplicationMenu());
     });
 }
 
 AbstractClient::~AbstractClient()
 {
     Q_ASSERT(m_blockGeometryUpdates == 0);
     Q_ASSERT(m_decoration.decoration == nullptr);
 }
 
 void AbstractClient::updateMouseGrab()
 {
 }
 
 bool AbstractClient::belongToSameApplication(const AbstractClient *c1, const AbstractClient *c2, SameApplicationChecks checks)
 {
     return c1->belongsToSameApplication(c2, checks);
 }
 
 bool AbstractClient::isTransient() const
 {
     return false;
 }
 
 void AbstractClient::setClientShown(bool shown)
 {
     Q_UNUSED(shown)
 }
 
 xcb_timestamp_t AbstractClient::userTime() const
 {
     return XCB_TIME_CURRENT_TIME;
 }
 
 void AbstractClient::setSkipSwitcher(bool set)
 {
     set = rules()->checkSkipSwitcher(set);
     if (set == skipSwitcher())
         return;
     m_skipSwitcher = set;
     doSetSkipSwitcher();
     updateWindowRules(Rules::SkipSwitcher);
     emit skipSwitcherChanged();
 }
 
 void AbstractClient::setSkipPager(bool b)
 {
     b = rules()->checkSkipPager(b);
     if (b == skipPager())
         return;
     m_skipPager = b;
     doSetSkipPager();
     updateWindowRules(Rules::SkipPager);
     emit skipPagerChanged();
 }
 
 void AbstractClient::doSetSkipPager()
 {
 }
 
 void AbstractClient::setSkipTaskbar(bool b)
 {
     int was_wants_tab_focus = wantsTabFocus();
     if (b == skipTaskbar())
         return;
     m_skipTaskbar = b;
     doSetSkipTaskbar();
     updateWindowRules(Rules::SkipTaskbar);
     if (was_wants_tab_focus != wantsTabFocus()) {
         FocusChain::self()->update(this, isActive() ? FocusChain::MakeFirst : FocusChain::Update);
     }
     emit skipTaskbarChanged();
 }
 
 void AbstractClient::setOriginalSkipTaskbar(bool b)
 {
     m_originalSkipTaskbar = rules()->checkSkipTaskbar(b);
     setSkipTaskbar(m_originalSkipTaskbar);
 }
 
 void AbstractClient::doSetSkipTaskbar()
 {
 
 }
 
 void AbstractClient::doSetSkipSwitcher()
 {
 
 }
 
 void AbstractClient::setIcon(const QIcon &icon)
 {
     m_icon = icon;
     emit iconChanged();
 }
 
 void AbstractClient::setActive(bool act)
 {
     if (m_active == act) {
         return;
     }
     m_active = act;
     const int ruledOpacity = m_active
                              ? rules()->checkOpacityActive(qRound(opacity() * 100.0))
                              : rules()->checkOpacityInactive(qRound(opacity() * 100.0));
     setOpacity(ruledOpacity / 100.0);
     workspace()->setActiveClient(act ? this : nullptr);
 
     if (!m_active)
         cancelAutoRaise();
 
     if (!m_active && shadeMode() == ShadeActivated)
         setShade(ShadeNormal);
 
     StackingUpdatesBlocker blocker(workspace());
     workspace()->updateClientLayer(this);   // active windows may get different layer
     auto mainclients = mainClients();
     for (auto it = mainclients.constBegin();
             it != mainclients.constEnd();
             ++it)
         if ((*it)->isFullScreen())  // fullscreens go high even if their transient is active
             workspace()->updateClientLayer(*it);
 
     doSetActive();
     emit activeChanged();
     updateMouseGrab();
 }
 
 void AbstractClient::doSetActive()
 {
 }
 
 Layer AbstractClient::layer() const
 {
     if (m_layer == UnknownLayer)
         const_cast< AbstractClient* >(this)->m_layer = belongsToLayer();
     return m_layer;
 }
 
 void AbstractClient::updateLayer()
 {
     if (layer() == belongsToLayer())
         return;
     StackingUpdatesBlocker blocker(workspace());
     invalidateLayer(); // invalidate, will be updated when doing restacking
     for (auto it = transients().constBegin(),
                                   end = transients().constEnd(); it != end; ++it)
         (*it)->updateLayer();
 }
 
+void AbstractClient::placeIn(const QRect &area)
+{
+    // TODO: Get rid of this method eventually. We need to call setGeometryRestore() because
+    // checkWorkspacePosition() operates on geometryRestore() and because of quick tiling.
+    Placement::self()->place(this, area);
+    setGeometryRestore(frameGeometry());
+}
+
 void AbstractClient::invalidateLayer()
 {
     m_layer = UnknownLayer;
 }
 
 Layer AbstractClient::belongsToLayer() const
 {
     // NOTICE while showingDesktop, desktops move to the AboveLayer
     // (interchangeable w/ eg. yakuake etc. which will at first remain visible)
     // and the docks move into the NotificationLayer (which is between Above- and
     // ActiveLayer, so that active fullscreen windows will still cover everything)
     // Since the desktop is also activated, nothing should be in the ActiveLayer, though
     if (isInternal())
         return UnmanagedLayer;
     if (isDesktop())
         return workspace()->showingDesktop() ? AboveLayer : DesktopLayer;
     if (isSplash())          // no damn annoying splashscreens
         return NormalLayer; // getting in the way of everything else
     if (isDock()) {
         if (workspace()->showingDesktop())
             return NotificationLayer;
         return layerForDock();
     }
     if (isOnScreenDisplay())
         return OnScreenDisplayLayer;
     if (isNotification())
         return NotificationLayer;
     if (isCriticalNotification())
         return CriticalNotificationLayer;
     if (workspace()->showingDesktop() && belongsToDesktop()) {
         return AboveLayer;
     }
     if (keepBelow())
         return BelowLayer;
     if (isActiveFullScreen())
         return ActiveLayer;
     if (keepAbove())
         return AboveLayer;
 
     return NormalLayer;
 }
 
 bool AbstractClient::belongsToDesktop() const
 {
     return false;
 }
 
 Layer AbstractClient::layerForDock() const
 {
     // slight hack for the 'allow window to cover panel' Kicker setting
     // don't move keepbelow docks below normal window, but only to the same
     // layer, so that both may be raised to cover the other
     if (keepBelow())
         return NormalLayer;
     if (keepAbove()) // slight hack for the autohiding panels
         return AboveLayer;
     return DockLayer;
 }
 
 void AbstractClient::setKeepAbove(bool b)
 {
     b = rules()->checkKeepAbove(b);
     if (b && !rules()->checkKeepBelow(false))
         setKeepBelow(false);
     if (b == keepAbove()) {
         return;
     }
     m_keepAbove = b;
     doSetKeepAbove();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Above);
 
     emit keepAboveChanged(m_keepAbove);
 }
 
 void AbstractClient::doSetKeepAbove()
 {
 }
 
 void AbstractClient::setKeepBelow(bool b)
 {
     b = rules()->checkKeepBelow(b);
     if (b && !rules()->checkKeepAbove(false))
         setKeepAbove(false);
     if (b == keepBelow()) {
         return;
     }
     m_keepBelow = b;
     doSetKeepBelow();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Below);
 
     emit keepBelowChanged(m_keepBelow);
 }
 
 void AbstractClient::doSetKeepBelow()
 {
 }
 
 void AbstractClient::startAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = new QTimer(this);
     connect(m_autoRaiseTimer, &QTimer::timeout, this, &AbstractClient::autoRaise);
     m_autoRaiseTimer->setSingleShot(true);
     m_autoRaiseTimer->start(options->autoRaiseInterval());
 }
 
 void AbstractClient::cancelAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = nullptr;
 }
 
 void AbstractClient::autoRaise()
 {
     workspace()->raiseClient(this);
     cancelAutoRaise();
 }
 
 bool AbstractClient::wantsTabFocus() const
 {
     return (isNormalWindow() || isDialog()) && wantsInput();
 }
 
 bool AbstractClient::isSpecialWindow() const
 {
     // TODO
     return isDesktop() || isDock() || isSplash() || isToolbar() || isNotification() || isOnScreenDisplay() || isCriticalNotification();
 }
 
 void AbstractClient::demandAttention(bool set)
 {
     if (isActive())
         set = false;
     if (m_demandsAttention == set)
         return;
     m_demandsAttention = set;
     doSetDemandsAttention();
     workspace()->clientAttentionChanged(this, set);
     emit demandsAttentionChanged();
 }
 
 void AbstractClient::doSetDemandsAttention()
 {
 }
 
 void AbstractClient::setDesktop(int desktop)
 {
     const int numberOfDesktops = VirtualDesktopManager::self()->count();
     if (desktop != NET::OnAllDesktops)   // Do range check
         desktop = qMax(1, qMin(numberOfDesktops, desktop));
     desktop = qMin(numberOfDesktops, rules()->checkDesktop(desktop));
 
     QVector<VirtualDesktop *> desktops;
     if (desktop != NET::OnAllDesktops) {
        desktops << VirtualDesktopManager::self()->desktopForX11Id(desktop);
     }
     setDesktops(desktops);
 }
 
 void AbstractClient::setDesktops(QVector<VirtualDesktop*> desktops)
 {
     //on x11 we can have only one desktop at a time
     if (kwinApp()->operationMode() == Application::OperationModeX11 && desktops.size() > 1) {
         desktops = QVector<VirtualDesktop*>({desktops.last()});
     }
 
     if (desktops == m_desktops) {
         return;
     }
 
     int was_desk = AbstractClient::desktop();
     const bool wasOnCurrentDesktop = isOnCurrentDesktop() && was_desk >= 0;
 
     m_desktops = desktops;
 
     if (windowManagementInterface()) {
         if (m_desktops.isEmpty()) {
             windowManagementInterface()->setOnAllDesktops(true);
         } else {
             windowManagementInterface()->setOnAllDesktops(false);
             auto currentDesktops = windowManagementInterface()->plasmaVirtualDesktops();
             for (auto desktop: m_desktops) {
                 if (!currentDesktops.contains(desktop->id())) {
                     windowManagementInterface()->addPlasmaVirtualDesktop(desktop->id());
                 } else {
                     currentDesktops.removeOne(desktop->id());
                 }
             }
             for (auto desktopId: currentDesktops) {
                 windowManagementInterface()->removePlasmaVirtualDesktop(desktopId);
             }
         }
     }
     if (info) {
         info->setDesktop(desktop());
     }
 
     if ((was_desk == NET::OnAllDesktops) != (desktop() == NET::OnAllDesktops)) {
         // onAllDesktops changed
         workspace()->updateOnAllDesktopsOfTransients(this);
     }
 
     auto transients_stacking_order = workspace()->ensureStackingOrder(transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it)
         (*it)->setDesktops(desktops);
 
     if (isModal())  // if a modal dialog is moved, move the mainwindow with it as otherwise
         // the (just moved) modal dialog will confusingly return to the mainwindow with
         // the next desktop change
     {
         foreach (AbstractClient * c2, mainClients())
         c2->setDesktops(desktops);
     }
 
     doSetDesktop();
 
     FocusChain::self()->update(this, FocusChain::MakeFirst);
     updateWindowRules(Rules::Desktop);
 
     emit desktopChanged();
     if (wasOnCurrentDesktop != isOnCurrentDesktop())
         emit desktopPresenceChanged(this, was_desk);
     emit x11DesktopIdsChanged();
 }
 
 void AbstractClient::doSetDesktop()
 {
 }
 
 void AbstractClient::enterDesktop(VirtualDesktop *virtualDesktop)
 {
     if (m_desktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = m_desktops;
     desktops.append(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::leaveDesktop(VirtualDesktop *virtualDesktop)
 {
     QVector<VirtualDesktop*> currentDesktops;
     if (m_desktops.isEmpty()) {
         currentDesktops = VirtualDesktopManager::self()->desktops();
     } else {
         currentDesktops = m_desktops;
     }
 
     if (!currentDesktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = currentDesktops;
     desktops.removeOne(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::setOnAllDesktops(bool b)
 {
     if ((b && isOnAllDesktops()) ||
             (!b && !isOnAllDesktops()))
         return;
     if (b)
         setDesktop(NET::OnAllDesktops);
     else
         setDesktop(VirtualDesktopManager::self()->current());
 }
 
 QVector<uint> AbstractClient::x11DesktopIds() const
 {
     const auto desks = desktops();
     QVector<uint> x11Ids;
     x11Ids.reserve(desks.count());
     std::transform(desks.constBegin(), desks.constEnd(),
         std::back_inserter(x11Ids),
         [] (const VirtualDesktop *vd) {
             return vd->x11DesktopNumber();
         }
     );
     return x11Ids;
 }
 
 bool AbstractClient::isShadeable() const
 {
     return false;
 }
 
 void AbstractClient::setShade(bool set)
 {
     set ? setShade(ShadeNormal) : setShade(ShadeNone);
 }
 
 void AbstractClient::setShade(ShadeMode mode)
 {
     Q_UNUSED(mode)
 }
 
 ShadeMode AbstractClient::shadeMode() const
 {
     return ShadeNone;
 }
 
 AbstractClient::Position AbstractClient::titlebarPosition() const
 {
     // TODO: still needed, remove?
     return PositionTop;
 }
 
 bool AbstractClient::titlebarPositionUnderMouse() const
 {
     if (!isDecorated()) {
         return false;
     }
     const auto sectionUnderMouse = decoration()->sectionUnderMouse();
     if (sectionUnderMouse == Qt::TitleBarArea) {
         return true;
     }
     // check other sections based on titlebarPosition
     switch (titlebarPosition()) {
     case AbstractClient::PositionTop:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::TopSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionLeft:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::LeftSection || sectionUnderMouse == Qt::BottomLeftSection);
     case AbstractClient::PositionRight:
         return (sectionUnderMouse == Qt::BottomRightSection || sectionUnderMouse == Qt::RightSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionBottom:
         return (sectionUnderMouse == Qt::BottomLeftSection || sectionUnderMouse == Qt::BottomSection || sectionUnderMouse == Qt::BottomRightSection);
     default:
         // nothing
         return false;
     }
 }
 
 void AbstractClient::setMinimized(bool set)
 {
     set ? minimize() : unminimize();
 }
 
 void AbstractClient::minimize(bool avoid_animation)
 {
     if (!isMinimizable() || isMinimized())
         return;
 
     m_minimized = true;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     FocusChain::self()->update(this, FocusChain::MakeFirstMinimized);
     // TODO: merge signal with s_minimized
     addWorkspaceRepaint(visibleRect());
     emit clientMinimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::unminimize(bool avoid_animation)
 {
     if (!isMinimized())
         return;
 
     if (rules()->checkMinimize(false)) {
         return;
     }
 
     m_minimized = false;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     emit clientUnminimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::doMinimize()
 {
 }
 
 QPalette AbstractClient::palette() const
 {
     if (!m_palette) {
         return QPalette();
     }
     return m_palette->palette();
 }
 
 const Decoration::DecorationPalette *AbstractClient::decorationPalette() const
 {
     return m_palette.get();
 }
 
 void AbstractClient::updateColorScheme(QString path)
 {
     if (path.isEmpty()) {
         path = QStringLiteral("kdeglobals");
     }
 
     if (!m_palette || m_colorScheme != path) {
         m_colorScheme = path;
 
         if (m_palette) {
             disconnect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
         }
 
         auto it = s_palettes.find(m_colorScheme);
 
         if (it == s_palettes.end() || it->expired()) {
             m_palette = std::make_shared<Decoration::DecorationPalette>(m_colorScheme);
             if (m_palette->isValid()) {
                 s_palettes[m_colorScheme] = m_palette;
             } else {
                 if (!s_defaultPalette) {
                     s_defaultPalette = std::make_shared<Decoration::DecorationPalette>(QStringLiteral("kdeglobals"));
                     s_palettes[QStringLiteral("kdeglobals")] = s_defaultPalette;
                 }
 
                 m_palette = s_defaultPalette;
             }
 
             if (m_colorScheme == QStringLiteral("kdeglobals")) {
                 s_defaultPalette = m_palette;
             }
         } else {
             m_palette = it->lock();
         }
 
         connect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
 
         emit paletteChanged(palette());
         emit colorSchemeChanged();
     }
 }
 
 void AbstractClient::handlePaletteChange()
 {
     emit paletteChanged(palette());
 }
 
 void AbstractClient::keepInArea(QRect area, bool partial)
 {
     if (partial) {
         // increase the area so that can have only 100 pixels in the area
         area.setLeft(qMin(area.left() - width() + 100, area.left()));
         area.setTop(qMin(area.top() - height() + 100, area.top()));
         area.setRight(qMax(area.right() + width() - 100, area.right()));
         area.setBottom(qMax(area.bottom() + height() - 100, area.bottom()));
     }
     if (!partial) {
         // resize to fit into area
         if (area.width() < width() || area.height() < height())
             resizeWithChecks(qMin(area.width(), width()), qMin(area.height(), height()));
     }
     int tx = x(), ty = y();
     if (frameGeometry().right() > area.right() && width() <= area.width())
         tx = area.right() - width() + 1;
     if (frameGeometry().bottom() > area.bottom() && height() <= area.height())
         ty = area.bottom() - height() + 1;
     if (!area.contains(frameGeometry().topLeft())) {
         if (tx < area.x())
             tx = area.x();
         if (ty < area.y())
             ty = area.y();
     }
     if (tx != x() || ty != y())
         move(tx, ty);
 }
 
 /**
  * Returns the maximum client size, not the maximum frame size.
  */
 QSize AbstractClient::maxSize() const
 {
     return rules()->checkMaxSize(QSize(INT_MAX, INT_MAX));
 }
 
 /**
  * Returns the minimum client size, not the minimum frame size.
  */
 QSize AbstractClient::minSize() const
 {
     return rules()->checkMinSize(QSize(0, 0));
 }
 
 void AbstractClient::blockGeometryUpdates(bool block)
 {
     if (block) {
         if (m_blockGeometryUpdates == 0)
             m_pendingGeometryUpdate = PendingGeometryNone;
         ++m_blockGeometryUpdates;
     } else {
         if (--m_blockGeometryUpdates == 0) {
             if (m_pendingGeometryUpdate != PendingGeometryNone) {
                 if (isShade())
                     setFrameGeometry(QRect(pos(), adjustedSize()), NormalGeometrySet);
                 else
                     setFrameGeometry(frameGeometry(), NormalGeometrySet);
                 m_pendingGeometryUpdate = PendingGeometryNone;
             }
         }
     }
 }
 
 void AbstractClient::maximize(MaximizeMode m)
 {
     setMaximize(m & MaximizeVertical, m & MaximizeHorizontal);
 }
 
 void AbstractClient::setMaximize(bool vertically, bool horizontally)
 {
     // changeMaximize() flips the state, so change from set->flip
     const MaximizeMode oldMode = maximizeMode();
     changeMaximize(
         oldMode & MaximizeHorizontal ? !horizontally : horizontally,
         oldMode & MaximizeVertical ? !vertically : vertically,
         false);
     const MaximizeMode newMode = maximizeMode();
     if (oldMode != newMode) {
         emit clientMaximizedStateChanged(this, newMode);
         emit clientMaximizedStateChanged(this, vertically, horizontally);
     }
 }
 
 void AbstractClient::move(int x, int y, ForceGeometry_t force)
 {
     // resuming geometry updates is handled only in setGeometry()
     Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
     QPoint p(x, y);
     if (!areGeometryUpdatesBlocked() && p != rules()->checkPosition(p)) {
         qCDebug(KWIN_CORE) << "forced position fail:" << p << ":" << rules()->checkPosition(p);
     }
     if (force == NormalGeometrySet && m_frameGeometry.topLeft() == p)
         return;
     m_frameGeometry.moveTopLeft(p);
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     doMove(x, y);
     updateWindowRules(Rules::Position);
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
     // client itself is not damaged
     emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 bool AbstractClient::startMoveResize()
 {
     Q_ASSERT(!isMoveResize());
     Q_ASSERT(QWidget::keyboardGrabber() == nullptr);
     Q_ASSERT(QWidget::mouseGrabber() == nullptr);
     stopDelayedMoveResize();
     if (QApplication::activePopupWidget() != nullptr)
         return false; // popups have grab
     if (isFullScreen() && (screens()->count() < 2 || !isMovableAcrossScreens()))
         return false;
     if (!doStartMoveResize()) {
         return false;
     }
 
     invalidateDecorationDoubleClickTimer();
 
     setMoveResize(true);
     workspace()->setMoveResizeClient(this);
 
     const Position mode = moveResizePointerMode();
     if (mode != PositionCenter) { // means "isResize()" but moveResizeMode = true is set below
         if (maximizeMode() == MaximizeFull) { // partial is cond. reset in finishMoveResize
             setGeometryRestore(frameGeometry()); // "restore" to current geometry
             setMaximize(false, false);
         }
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet
         // Exit quick tile mode when the user attempts to resize a tiled window
         updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry
         setGeometryRestore(frameGeometry());
         emit quickTileModeChanged();
     }
 
     updateHaveResizeEffect();
     updateInitialMoveResizeGeometry();
     checkUnrestrictedMoveResize();
     emit clientStartUserMovedResized(this);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(true, Qt::Vertical|Qt::Horizontal);
     return true;
 }
 
 void AbstractClient::finishMoveResize(bool cancel)
 {
     GeometryUpdatesBlocker blocker(this);
     const bool wasResize = isResize(); // store across leaveMoveResize
     leaveMoveResize();
 
     if (cancel)
         setFrameGeometry(initialMoveResizeGeometry());
     else {
         const QRect &moveResizeGeom = moveResizeGeometry();
         if (wasResize) {
             const bool restoreH = maximizeMode() == MaximizeHorizontal &&
                                     moveResizeGeom.width() != initialMoveResizeGeometry().width();
             const bool restoreV = maximizeMode() == MaximizeVertical &&
                                     moveResizeGeom.height() != initialMoveResizeGeometry().height();
             if (restoreH || restoreV) {
                 changeMaximize(restoreH, restoreV, false);
             }
         }
         setFrameGeometry(moveResizeGeom);
     }
     checkScreen(); // needs to be done because clientFinishUserMovedResized has not yet re-activated online alignment
     if (screen() != moveResizeStartScreen()) {
         workspace()->sendClientToScreen(this, screen()); // checks rule validity
         if (maximizeMode() != MaximizeRestore)
             checkWorkspacePosition();
     }
 
     if (isElectricBorderMaximizing()) {
         setQuickTileMode(electricBorderMode());
         setElectricBorderMaximizing(false);
     } else if (!cancel) {
         QRect geom_restore = geometryRestore();
         if (!(maximizeMode() & MaximizeHorizontal)) {
             geom_restore.setX(frameGeometry().x());
             geom_restore.setWidth(frameGeometry().width());
         }
         if (!(maximizeMode() & MaximizeVertical)) {
             geom_restore.setY(frameGeometry().y());
             geom_restore.setHeight(frameGeometry().height());
         }
         setGeometryRestore(geom_restore);
     }
 // FRAME    update();
 
     emit clientFinishUserMovedResized(this);
 }
 
 // This function checks if it actually makes sense to perform a restricted move/resize.
 // If e.g. the titlebar is already outside of the workarea, there's no point in performing
 // a restricted move resize, because then e.g. resize would also move the window (#74555).
 // NOTE: Most of it is duplicated from handleMoveResize().
 void AbstractClient::checkUnrestrictedMoveResize()
 {
     if (isUnrestrictedMoveResize())
         return;
     const QRect &moveResizeGeom = moveResizeGeometry();
     QRect desktopArea = workspace()->clientArea(WorkArea, moveResizeGeom.center(), desktop());
     int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
     // restricted move/resize - keep at least part of the titlebar always visible
     // how much must remain visible when moved away in that direction
     left_marge = qMin(100 + borderRight(), moveResizeGeom.width());
     right_marge = qMin(100 + borderLeft(), moveResizeGeom.width());
     // width/height change with opaque resizing, use the initial ones
     titlebar_marge = initialMoveResizeGeometry().height();
     top_marge = borderBottom();
     bottom_marge = borderTop();
     if (isResize()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + top_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
         if (!isUnrestrictedMoveResize() && moveResizeGeom.top() < desktopArea.top())   // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
     }
     if (isMove()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1)
             setUnrestrictedMoveResize(true);
         // no need to check top_marge, titlebar_marge already handles it
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge + 1) // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
     }
 }
 
 // When the user pressed mouse on the titlebar, don't activate move immediatelly,
 // since it may be just a click. Activate instead after a delay. Move used to be
 // activated only after moving by several pixels, but that looks bad.
 void AbstractClient::startDelayedMoveResize()
 {
     Q_ASSERT(!m_moveResize.delayedTimer);
     m_moveResize.delayedTimer = new QTimer(this);
     m_moveResize.delayedTimer->setSingleShot(true);
     connect(m_moveResize.delayedTimer, &QTimer::timeout, this,
         [this]() {
             Q_ASSERT(isMoveResizePointerButtonDown());
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
             }
             updateCursor();
             stopDelayedMoveResize();
         }
     );
     m_moveResize.delayedTimer->start(QApplication::startDragTime());
 }
 
 void AbstractClient::stopDelayedMoveResize()
 {
     delete m_moveResize.delayedTimer;
     m_moveResize.delayedTimer = nullptr;
 }
 
 void AbstractClient::updateMoveResize(const QPointF &currentGlobalCursor)
 {
     handleMoveResize(pos(), currentGlobalCursor.toPoint());
 }
 
 void AbstractClient::handleMoveResize(const QPoint &local, const QPoint &global)
 {
     const QRect oldGeo = frameGeometry();
     handleMoveResize(local.x(), local.y(), global.x(), global.y());
     if (!isFullScreen() && isMove()) {
         if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != frameGeometry()) {
             GeometryUpdatesBlocker blocker(this);
             setQuickTileMode(QuickTileFlag::None);
             const QRect &geom_restore = geometryRestore();
             setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()),
                                  double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height())));
             if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore)
                 setMoveResizeGeometry(geom_restore);
             handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) {
             checkQuickTilingMaximizationZones(global.x(), global.y());
         }
     }
 }
 
 void AbstractClient::handleMoveResize(int x, int y, int x_root, int y_root)
 {
     if (isWaitingForMoveResizeSync())
         return; // we're still waiting for the client or the timeout
 
     const Position mode = moveResizePointerMode();
     if ((mode == PositionCenter && !isMovableAcrossScreens())
             || (mode != PositionCenter && (isShade() || !isResizable())))
         return;
 
     if (!isMoveResize()) {
         QPoint p(QPoint(x/* - padding_left*/, y/* - padding_top*/) - moveOffset());
         if (p.manhattanLength() >= QApplication::startDragDistance()) {
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
                 updateCursor();
                 return;
             }
             updateCursor();
         } else
             return;
     }
 
     // ShadeHover or ShadeActive, ShadeNormal was already avoided above
     if (mode != PositionCenter && shadeMode() != ShadeNone)
         setShade(ShadeNone);
 
     QPoint globalPos(x_root, y_root);
     // these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
     // the bottomleft corner should be at is at (topleft.x(), bottomright().y())
     QPoint topleft = globalPos - moveOffset();
     QPoint bottomright = globalPos + invertedMoveOffset();
     QRect previousMoveResizeGeom = moveResizeGeometry();
 
     // TODO move whole group when moving its leader or when the leader is not mapped?
 
     auto titleBarRect = [this](bool &transposed, int &requiredPixels) -> QRect {
         const QRect &moveResizeGeom = moveResizeGeometry();
         QRect r(moveResizeGeom);
         r.moveTopLeft(QPoint(0,0));
         switch (titlebarPosition()) {
         default:
         case PositionTop:
             r.setHeight(borderTop());
             break;
         case PositionLeft:
             r.setWidth(borderLeft());
             transposed = true;
             break;
         case PositionBottom:
             r.setTop(r.bottom() - borderBottom());
             break;
         case PositionRight:
             r.setLeft(r.right() - borderRight());
             transposed = true;
             break;
         }
         // When doing a restricted move we must always keep 100px of the titlebar
         // visible to allow the user to be able to move it again.
         requiredPixels = qMin(100 * (transposed ? r.width() : r.height()),
                               moveResizeGeom.width() * moveResizeGeom.height());
         return r;
     };
 
     bool update = false;
     if (isResize()) {
         QRect orig = initialMoveResizeGeometry();
         SizeMode sizeMode = SizeModeAny;
         auto calculateMoveResizeGeom = [this, &topleft, &bottomright, &orig, &sizeMode, &mode]() {
             switch(mode) {
             case PositionTopLeft:
                 setMoveResizeGeometry(QRect(topleft, orig.bottomRight()));
                 break;
             case PositionBottomRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), bottomright));
                 break;
             case PositionBottomLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.y()), QPoint(orig.right(), bottomright.y())));
                 break;
             case PositionTopRight:
                 setMoveResizeGeometry(QRect(QPoint(orig.x(), topleft.y()), QPoint(bottomright.x(), orig.bottom())));
                 break;
             case PositionTop:
                 setMoveResizeGeometry(QRect(QPoint(orig.left(), topleft.y()), orig.bottomRight()));
                 sizeMode = SizeModeFixedH; // try not to affect height
                 break;
             case PositionBottom:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(orig.right(), bottomright.y())));
                 sizeMode = SizeModeFixedH;
                 break;
             case PositionLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.top()), orig.bottomRight()));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(bottomright.x(), orig.bottom())));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionCenter:
             default:
                 abort();
                 break;
             }
         };
 
         // first resize (without checking constrains), then snap, then check bounds, then check constrains
         calculateMoveResizeGeom();
         // adjust new size to snap to other windows/borders
         setMoveResizeGeometry(workspace()->adjustClientSize(this, moveResizeGeometry(), mode));
 
         if (!isUnrestrictedMoveResize()) {
             // Make sure the titlebar isn't behind a restricted area. We don't need to restrict
             // the other directions. If not visible enough, move the window to the closest valid
             // point. We bruteforce this by slowly moving the window back to its previous position
             QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
             availableArea -= workspace()->restrictedMoveArea(desktop());   // Strut areas
             bool transposed = false;
             int requiredPixels;
             QRect bTitleRect = titleBarRect(transposed, requiredPixels);
             int lastVisiblePixels = -1;
             QRect lastTry = moveResizeGeometry();
             bool titleFailed = false;
             for (;;) {
                 const QRect titleRect(bTitleRect.translated(moveResizeGeometry().topLeft()));
                 int visiblePixels = 0;
                 int realVisiblePixels = 0;
                 for (const QRect &rect : availableArea) {
                     const QRect r = rect & titleRect;
                     realVisiblePixels += r.width() * r.height();
                     if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                         (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                         visiblePixels += r.width() * r.height();
                 }
 
                 if (visiblePixels >= requiredPixels)
                     break; // We have reached a valid position
 
                 if (realVisiblePixels <= lastVisiblePixels) {
                     if (titleFailed && realVisiblePixels < lastVisiblePixels)
                         break; // we won't become better
                     else {
                         if (!titleFailed)
                             setMoveResizeGeometry(lastTry);
                         titleFailed = true;
                     }
                 }
                 lastVisiblePixels = realVisiblePixels;
                 QRect moveResizeGeom = moveResizeGeometry();
                 lastTry = moveResizeGeom;
 
                 // Not visible enough, move the window to the closest valid point. We bruteforce
                 // this by slowly moving the window back to its previous position.
                 // The geometry changes at up to two edges, the one with the title (if) shall take
                 // precedence. The opposing edge has no impact on visiblePixels and only one of
                 // the adjacent can alter at a time, ie. it's enough to ignore adjacent edges
                 // if the title edge altered
                 bool leftChanged  = previousMoveResizeGeom.left()   != moveResizeGeom.left();
                 bool rightChanged = previousMoveResizeGeom.right()  != moveResizeGeom.right();
                 bool topChanged   = previousMoveResizeGeom.top()    != moveResizeGeom.top();
                 bool btmChanged   = previousMoveResizeGeom.bottom() != moveResizeGeom.bottom();
                 auto fixChangedState = [titleFailed](bool &major, bool &counter, bool &ad1, bool &ad2) {
                     counter = false;
                     if (titleFailed)
                         major = false;
                     if (major)
                         ad1 = ad2 = false;
                 };
                 switch (titlebarPosition()) {
                 default:
                 case PositionTop:
                     fixChangedState(topChanged, btmChanged, leftChanged, rightChanged);
                     break;
                 case PositionLeft:
                     fixChangedState(leftChanged, rightChanged, topChanged, btmChanged);
                     break;
                 case PositionBottom:
                     fixChangedState(btmChanged, topChanged, leftChanged, rightChanged);
                     break;
                 case PositionRight:
                     fixChangedState(rightChanged, leftChanged, topChanged, btmChanged);
                     break;
                 }
                 if (topChanged)
                     moveResizeGeom.setTop(moveResizeGeom.y() + sign(previousMoveResizeGeom.y() - moveResizeGeom.y()));
                 else if (leftChanged)
                     moveResizeGeom.setLeft(moveResizeGeom.x() + sign(previousMoveResizeGeom.x() - moveResizeGeom.x()));
                 else if (btmChanged)
                     moveResizeGeom.setBottom(moveResizeGeom.bottom() + sign(previousMoveResizeGeom.bottom() - moveResizeGeom.bottom()));
                 else if (rightChanged)
                     moveResizeGeom.setRight(moveResizeGeom.right() + sign(previousMoveResizeGeom.right() - moveResizeGeom.right()));
                 else
                     break; // no position changed - that's certainly not good
                 setMoveResizeGeometry(moveResizeGeom);
             }
         }
 
         // Always obey size hints, even when in "unrestricted" mode
         QSize size = constrainFrameSize(moveResizeGeometry().size(), sizeMode);
         // the new topleft and bottomright corners (after checking size constrains), if they'll be needed
         topleft = QPoint(moveResizeGeometry().right() - size.width() + 1, moveResizeGeometry().bottom() - size.height() + 1);
         bottomright = QPoint(moveResizeGeometry().left() + size.width() - 1, moveResizeGeometry().top() + size.height() - 1);
         orig = moveResizeGeometry();
 
         // if aspect ratios are specified, both dimensions may change.
         // Therefore grow to the right/bottom if needed.
         // TODO it should probably obey gravity rather than always using right/bottom ?
         if (sizeMode == SizeModeFixedH)
             orig.setRight(bottomright.x());
         else if (sizeMode == SizeModeFixedW)
             orig.setBottom(bottomright.y());
 
         calculateMoveResizeGeom();
 
         if (moveResizeGeometry().size() != previousMoveResizeGeom.size())
             update = true;
     } else if (isMove()) {
         Q_ASSERT(mode == PositionCenter);
         if (!isMovable()) { // isMovableAcrossScreens() must have been true to get here
             // Special moving of maximized windows on Xinerama screens
             int screen = screens()->number(globalPos);
             if (isFullScreen())
                 setMoveResizeGeometry(workspace()->clientArea(FullScreenArea, screen, 0));
             else {
                 QRect moveResizeGeom = workspace()->clientArea(MaximizeArea, screen, 0);
                 QSize adjSize = constrainFrameSize(moveResizeGeom.size(), SizeModeMax);
                 if (adjSize != moveResizeGeom.size()) {
                     QRect r(moveResizeGeom);
                     moveResizeGeom.setSize(adjSize);
                     moveResizeGeom.moveCenter(r.center());
                 }
                 setMoveResizeGeometry(moveResizeGeom);
             }
         } else {
             // first move, then snap, then check bounds
             QRect moveResizeGeom = moveResizeGeometry();
             moveResizeGeom.moveTopLeft(topleft);
             moveResizeGeom.moveTopLeft(workspace()->adjustClientPosition(this, moveResizeGeom.topLeft(),
                                        isUnrestrictedMoveResize()));
             setMoveResizeGeometry(moveResizeGeom);
 
             if (!isUnrestrictedMoveResize()) {
                 const QRegion strut = workspace()->restrictedMoveArea(desktop());   // Strut areas
                 QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
                 availableArea -= strut;   // Strut areas
                 bool transposed = false;
                 int requiredPixels;
                 QRect bTitleRect = titleBarRect(transposed, requiredPixels);
                 for (;;) {
                     QRect moveResizeGeom = moveResizeGeometry();
                     const QRect titleRect(bTitleRect.translated(moveResizeGeom.topLeft()));
                     int visiblePixels = 0;
                     for (const QRect &rect : availableArea) {
                         const QRect r = rect & titleRect;
                         if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                             (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                             visiblePixels += r.width() * r.height();
                     }
                     if (visiblePixels >= requiredPixels)
                         break; // We have reached a valid position
 
                     // (esp.) if there're more screens with different struts (panels) it the titlebar
                     // will be movable outside the movearea (covering one of the panels) until it
                     // crosses the panel "too much" (not enough visiblePixels) and then stucks because
                     // it's usually only pushed by 1px to either direction
                     // so we first check whether we intersect suc strut and move the window below it
                     // immediately (it's still possible to hit the visiblePixels >= titlebarArea break
                     // by moving the window slightly downwards, but it won't stuck)
                     // see bug #274466
                     // and bug #301805 for why we can't just match the titlearea against the screen
                     if (screens()->count() > 1) { // optimization
                         // TODO: could be useful on partial screen struts (half-width panels etc.)
                         int newTitleTop = -1;
                         for (const QRect &r : strut) {
                             if (r.top() == 0 && r.width() > r.height() && // "top panel"
                                 r.intersects(moveResizeGeom) && moveResizeGeom.top() < r.bottom()) {
                                 newTitleTop = r.bottom() + 1;
                                 break;
                             }
                         }
                         if (newTitleTop > -1) {
                             moveResizeGeom.moveTop(newTitleTop); // invalid position, possibly on screen change
                             setMoveResizeGeometry(moveResizeGeom);
                             break;
                         }
                     }
 
                     int dx = sign(previousMoveResizeGeom.x() - moveResizeGeom.x()),
                         dy = sign(previousMoveResizeGeom.y() - moveResizeGeom.y());
                     if (visiblePixels && dx) // means there's no full width cap -> favor horizontally
                         dy = 0;
                     else if (dy)
                         dx = 0;
 
                     // Move it back
                     moveResizeGeom.translate(dx, dy);
                     setMoveResizeGeometry(moveResizeGeom);
 
                     if (moveResizeGeom == previousMoveResizeGeom) {
                         break; // Prevent lockup
                     }
                 }
             }
         }
         if (moveResizeGeometry().topLeft() != previousMoveResizeGeom.topLeft())
             update = true;
     } else
         abort();
 
     if (!update)
         return;
 
     if (isResize() && !haveResizeEffect()) {
         doResizeSync();
     } else
         performMoveResize();
 
     if (isMove()) {
         ScreenEdges::self()->check(globalPos, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC));
     }
 }
 
 void AbstractClient::performMoveResize()
 {
     const QRect &moveResizeGeom = moveResizeGeometry();
     if (isMove() || (isResize() && !haveResizeEffect())) {
         setFrameGeometry(moveResizeGeom);
     }
     doPerformMoveResize();
     positionGeometryTip();
     emit clientStepUserMovedResized(this, moveResizeGeom);
 }
 
 bool AbstractClient::hasStrut() const
 {
     return false;
 }
 
 void AbstractClient::setupWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         // already setup
         return;
     }
     if (!waylandServer() || !surface()) {
         return;
     }
     if (!waylandServer()->windowManagement()) {
         return;
     }
     using namespace KWayland::Server;
     auto w = waylandServer()->windowManagement()->createWindow(waylandServer()->windowManagement());
     w->setTitle(caption());
     w->setVirtualDesktop(isOnAllDesktops() ? 0 : desktop() - 1);
     w->setActive(isActive());
     w->setFullscreen(isFullScreen());
     w->setKeepAbove(keepAbove());
     w->setKeepBelow(keepBelow());
     w->setMaximized(maximizeMode() == KWin::MaximizeFull);
     w->setMinimized(isMinimized());
     w->setOnAllDesktops(isOnAllDesktops());
     w->setDemandsAttention(isDemandingAttention());
     w->setCloseable(isCloseable());
     w->setMaximizeable(isMaximizable());
     w->setMinimizeable(isMinimizable());
     w->setFullscreenable(isFullScreenable());
     w->setIcon(icon());
     auto updateAppId = [this, w] {
         w->setAppId(QString::fromUtf8(m_desktopFileName.isEmpty() ? resourceClass() : m_desktopFileName));
     };
     updateAppId();
     w->setSkipTaskbar(skipTaskbar());
     w->setSkipSwitcher(skipSwitcher());
     w->setPid(pid());
     w->setShadeable(isShadeable());
     w->setShaded(isShade());
     w->setResizable(isResizable());
     w->setMovable(isMovable());
     w->setVirtualDesktopChangeable(true); // FIXME Matches X11Client::actionSupported(), but both should be implemented.
     w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
     w->setGeometry(frameGeometry());
     connect(this, &AbstractClient::skipTaskbarChanged, w,
         [w, this] {
             w->setSkipTaskbar(skipTaskbar());
         }
     );
     connect(this, &AbstractClient::skipSwitcherChanged, w,
          [w, this] {
             w->setSkipSwitcher(skipSwitcher());
         }
     );
     connect(this, &AbstractClient::captionChanged, w, [w, this] { w->setTitle(caption()); });
 
     connect(this, &AbstractClient::activeChanged, w, [w, this] { w->setActive(isActive()); });
     connect(this, &AbstractClient::fullScreenChanged, w, [w, this] { w->setFullscreen(isFullScreen()); });
     connect(this, &AbstractClient::keepAboveChanged, w, &PlasmaWindowInterface::setKeepAbove);
     connect(this, &AbstractClient::keepBelowChanged, w, &PlasmaWindowInterface::setKeepBelow);
     connect(this, &AbstractClient::minimizedChanged, w, [w, this] { w->setMinimized(isMinimized()); });
     connect(this, static_cast<void (AbstractClient::*)(AbstractClient*,MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged), w,
         [w] (KWin::AbstractClient *c, MaximizeMode mode) {
             Q_UNUSED(c);
             w->setMaximized(mode == KWin::MaximizeFull);
         }
     );
     connect(this, &AbstractClient::demandsAttentionChanged, w, [w, this] { w->setDemandsAttention(isDemandingAttention()); });
     connect(this, &AbstractClient::iconChanged, w,
         [w, this] {
             w->setIcon(icon());
         }
     );
     connect(this, &AbstractClient::windowClassChanged, w, updateAppId);
     connect(this, &AbstractClient::desktopFileNameChanged, w, updateAppId);
     connect(this, &AbstractClient::shadeChanged, w, [w, this] { w->setShaded(isShade()); });
     connect(this, &AbstractClient::transientChanged, w,
         [w, this] {
             w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
         }
     );
     connect(this, &AbstractClient::frameGeometryChanged, w,
         [w, this] {
             w->setGeometry(frameGeometry());
         }
     );
     connect(w, &PlasmaWindowInterface::closeRequested, this, [this] { closeWindow(); });
     connect(w, &PlasmaWindowInterface::moveRequested, this,
         [this] {
             Cursor::setPos(frameGeometry().center());
             performMouseCommand(Options::MouseMove, Cursor::pos());
         }
     );
     connect(w, &PlasmaWindowInterface::resizeRequested, this,
         [this] {
             Cursor::setPos(frameGeometry().bottomRight());
             performMouseCommand(Options::MouseResize, Cursor::pos());
         }
     );
     connect(w, &PlasmaWindowInterface::virtualDesktopRequested, this,
         [this] (quint32 desktop) {
             workspace()->sendClientToDesktop(this, desktop + 1, true);
         }
     );
     connect(w, &PlasmaWindowInterface::fullscreenRequested, this,
         [this] (bool set) {
             setFullScreen(set, false);
         }
     );
     connect(w, &PlasmaWindowInterface::minimizedRequested, this,
         [this] (bool set) {
             if (set) {
                 minimize();
             } else {
                 unminimize();
             }
         }
     );
     connect(w, &PlasmaWindowInterface::maximizedRequested, this,
         [this] (bool set) {
             maximize(set ? MaximizeFull : MaximizeRestore);
         }
     );
     connect(w, &PlasmaWindowInterface::keepAboveRequested, this,
         [this] (bool set) {
             setKeepAbove(set);
         }
     );
     connect(w, &PlasmaWindowInterface::keepBelowRequested, this,
         [this] (bool set) {
             setKeepBelow(set);
         }
     );
     connect(w, &PlasmaWindowInterface::demandsAttentionRequested, this,
         [this] (bool set) {
             demandAttention(set);
         }
     );
     connect(w, &PlasmaWindowInterface::activeRequested, this,
         [this] (bool set) {
             if (set) {
                 workspace()->activateClient(this, true);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::shadedRequested, this,
         [this] (bool set) {
             setShade(set);
         }
     );
 
     for (const auto vd : m_desktops) {
         w->addPlasmaVirtualDesktop(vd->id());
     }
 
     //this is only for the legacy
     connect(this, &AbstractClient::desktopChanged, w,
         [w, this] {
             if (isOnAllDesktops()) {
                 w->setOnAllDesktops(true);
                 return;
             }
             w->setVirtualDesktop(desktop() - 1);
             w->setOnAllDesktops(false);
         }
     );
 
     //Plasma Virtual desktop management
     //show/hide when the window enters/exits from desktop
     connect(w, &PlasmaWindowInterface::enterPlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 enterDesktop(vd);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::enterNewPlasmaVirtualDesktopRequested, this,
         [this] () {
             VirtualDesktopManager::self()->setCount(VirtualDesktopManager::self()->count() + 1);
             enterDesktop(VirtualDesktopManager::self()->desktops().last());
         }
     );
     connect(w, &PlasmaWindowInterface::leavePlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 leaveDesktop(vd);
             }
         }
     );
 
     m_windowManagementInterface = w;
 }
 
 void AbstractClient::destroyWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         m_windowManagementInterface->unmap();
         m_windowManagementInterface = nullptr;
     }
 }
 
 Options::MouseCommand AbstractClient::getMouseCommand(Qt::MouseButton button, bool *handled) const
 {
     *handled = false;
     if (button == Qt::NoButton) {
         return Options::MouseNothing;
     }
     if (isActive()) {
         if (options->isClickRaise()) {
             *handled = true;
             return Options::MouseActivateRaiseAndPassClick;
         }
     } else {
         *handled = true;
         switch (button) {
         case Qt::LeftButton:
             return options->commandWindow1();
         case Qt::MiddleButton:
             return options->commandWindow2();
         case Qt::RightButton:
             return options->commandWindow3();
         default:
             // all other buttons pass Activate & Pass Client
             return Options::MouseActivateAndPassClick;
         }
     }
     return Options::MouseNothing;
 }
 
 Options::MouseCommand AbstractClient::getWheelCommand(Qt::Orientation orientation, bool *handled) const
 {
     *handled = false;
     if (orientation != Qt::Vertical) {
         return Options::MouseNothing;
     }
     if (!isActive()) {
         *handled = true;
         return options->commandWindowWheel();
     }
     return Options::MouseNothing;
 }
 
 bool AbstractClient::performMouseCommand(Options::MouseCommand cmd, const QPoint &globalPos)
 {
     bool replay = false;
     switch(cmd) {
     case Options::MouseRaise:
         workspace()->raiseClient(this);
         break;
     case Options::MouseLower: {
         workspace()->lowerClient(this);
         // used to be activateNextClient(this), then topClientOnDesktop
         // since this is a mouseOp it's however safe to use the client under the mouse instead
         if (isActive() && options->focusPolicyIsReasonable()) {
             AbstractClient *next = workspace()->clientUnderMouse(screen());
             if (next && next != this)
                 workspace()->requestFocus(next, false);
         }
         break;
     }
     case Options::MouseOperationsMenu:
         if (isActive() && options->isClickRaise())
             autoRaise();
         workspace()->showWindowMenu(QRect(globalPos, globalPos), this);
         break;
     case Options::MouseToggleRaiseAndLower:
         workspace()->raiseOrLowerClient(this);
         break;
     case Options::MouseActivateAndRaise: {
         replay = isActive(); // for clickraise mode
         bool mustReplay = !rules()->checkAcceptFocus(acceptsFocus());
         if (mustReplay) {
             auto it = workspace()->stackingOrder().constEnd(),
                                      begin = workspace()->stackingOrder().constBegin();
             while (mustReplay && --it != begin && *it != this) {
                 AbstractClient *c = qobject_cast<AbstractClient*>(*it);
                 if (!c || (c->keepAbove() && !keepAbove()) || (keepBelow() && !c->keepBelow()))
                     continue; // can never raise above "it"
                 mustReplay = !(c->isOnCurrentDesktop() && c->isOnCurrentActivity() && c->frameGeometry().intersects(frameGeometry()));
             }
         }
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = replay || mustReplay;
         break;
     }
     case Options::MouseActivateAndLower:
         workspace()->requestFocus(this);
         workspace()->lowerClient(this);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivate:
         replay = isActive(); // for clickraise mode
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivateRaiseAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseActivateAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseMaximize:
         maximize(MaximizeFull);
         break;
     case Options::MouseRestore:
         maximize(MaximizeRestore);
         break;
     case Options::MouseMinimize:
         minimize();
         break;
     case Options::MouseAbove: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepBelow())
             setKeepBelow(false);
         else
             setKeepAbove(true);
         break;
     }
     case Options::MouseBelow: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepAbove())
             setKeepAbove(false);
         else
             setKeepBelow(true);
         break;
     }
     case Options::MousePreviousDesktop:
         workspace()->windowToPreviousDesktop(this);
         break;
     case Options::MouseNextDesktop:
         workspace()->windowToNextDesktop(this);
         break;
     case Options::MouseOpacityMore:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMin(opacity() + 0.1, 1.0));
         break;
     case Options::MouseOpacityLess:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMax(opacity() - 0.1, 0.1));
         break;
     case Options::MouseClose:
         closeWindow();
         break;
     case Options::MouseActivateRaiseAndMove:
     case Options::MouseActivateRaiseAndUnrestrictedMove:
         workspace()->raiseClient(this);
         workspace()->requestFocus(this);
         screens()->setCurrent(globalPos);
         // fallthrough
     case Options::MouseMove:
     case Options::MouseUnrestrictedMove: {
         if (!isMovableAcrossScreens())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerMode(PositionCenter);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(globalPos.x() - x(), globalPos.y() - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize((cmd == Options::MouseActivateRaiseAndUnrestrictedMove
                                   || cmd == Options::MouseUnrestrictedMove));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
     case Options::MouseResize:
     case Options::MouseUnrestrictedResize: {
         if (!isResizable() || isShade())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         const QPoint moveOffset = QPoint(globalPos.x() - x(), globalPos.y() - y());  // map from global
         setMoveOffset(moveOffset);
         int x = moveOffset.x(), y = moveOffset.y();
         bool left = x < width() / 3;
         bool right = x >= 2 * width() / 3;
         bool top = y < height() / 3;
         bool bot = y >= 2 * height() / 3;
         Position mode;
         if (top)
             mode = left ? PositionTopLeft : (right ? PositionTopRight : PositionTop);
         else if (bot)
             mode = left ? PositionBottomLeft : (right ? PositionBottomRight : PositionBottom);
         else
             mode = (x < width() / 2) ? PositionLeft : PositionRight;
         setMoveResizePointerMode(mode);
         setInvertedMoveOffset(rect().bottomRight() - moveOffset);
         setUnrestrictedMoveResize((cmd == Options::MouseUnrestrictedResize));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
     case Options::MouseNothing:
     default:
         replay = true;
         break;
     }
     return replay;
 }
 
 void AbstractClient::setTransientFor(AbstractClient *transientFor)
 {
     if (transientFor == this) {
         // cannot be transient for one self
         return;
     }
     if (m_transientFor == transientFor) {
         return;
     }
     m_transientFor = transientFor;
     emit transientChanged();
 }
 
 const AbstractClient *AbstractClient::transientFor() const
 {
     return m_transientFor;
 }
 
 AbstractClient *AbstractClient::transientFor()
 {
     return m_transientFor;
 }
 
 bool AbstractClient::hasTransientPlacementHint() const
 {
     return false;
 }
 
 QRect AbstractClient::transientPlacement(const QRect &bounds) const
 {
     Q_UNUSED(bounds);
     Q_UNREACHABLE();
     return QRect();
 }
 
 bool AbstractClient::hasTransient(const AbstractClient *c, bool indirect) const
 {
     Q_UNUSED(indirect);
     return c->transientFor() == this;
 }
 
 QList< AbstractClient* > AbstractClient::mainClients() const
 {
     if (const AbstractClient *t = transientFor()) {
         return QList<AbstractClient*>{const_cast< AbstractClient* >(t)};
     }
     return QList<AbstractClient*>();
 }
 
 QList<AbstractClient*> AbstractClient::allMainClients() const
 {
     auto result = mainClients();
     foreach (const auto *cl, result) {
         result += cl->allMainClients();
     }
     return result;
 }
 
 void AbstractClient::setModal(bool m)
 {
     // Qt-3.2 can have even modal normal windows :(
     if (m_modal == m)
         return;
     m_modal = m;
     emit modalChanged();
     // Changing modality for a mapped window is weird (?)
     // _NET_WM_STATE_MODAL should possibly rather be _NET_WM_WINDOW_TYPE_MODAL_DIALOG
 }
 
 bool AbstractClient::isModal() const
 {
     return m_modal;
 }
 
 void AbstractClient::addTransient(AbstractClient *cl)
 {
     Q_ASSERT(!m_transients.contains(cl));
     Q_ASSERT(cl != this);
     m_transients.append(cl);
 }
 
 void AbstractClient::removeTransient(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
     if (cl->transientFor() == this) {
         cl->setTransientFor(nullptr);
     }
 }
 
 void AbstractClient::removeTransientFromList(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
 }
 
 bool AbstractClient::isActiveFullScreen() const
 {
     if (!isFullScreen())
         return false;
 
     const auto ac = workspace()->mostRecentlyActivatedClient(); // instead of activeClient() - avoids flicker
     // according to NETWM spec implementation notes suggests
     // "focused windows having state _NET_WM_STATE_FULLSCREEN" to be on the highest layer.
     // we'll also take the screen into account
     return ac && (ac == this || ac->screen() != screen()|| ac->allMainClients().contains(const_cast<AbstractClient*>(this)));
 }
 
 #define BORDER(which) \
     int AbstractClient::border##which() const \
     { \
         return isDecorated() ? decoration()->border##which() : 0; \
     }
 
 BORDER(Bottom)
 BORDER(Left)
 BORDER(Right)
 BORDER(Top)
 #undef BORDER
 
 void AbstractClient::addRepaintDuringGeometryUpdates()
 {
     const QRect deco_rect = visibleRect();
     addLayerRepaint(m_visibleRectBeforeGeometryUpdate);
     addLayerRepaint(deco_rect);   // trigger repaint of window's new location
     m_visibleRectBeforeGeometryUpdate = deco_rect;
 }
 
 QRect AbstractClient::bufferGeometryBeforeUpdateBlocking() const
 {
     return m_bufferGeometryBeforeUpdateBlocking;
 }
 
 QRect AbstractClient::frameGeometryBeforeUpdateBlocking() const
 {
     return m_frameGeometryBeforeUpdateBlocking;
 }
 
 void AbstractClient::updateGeometryBeforeUpdateBlocking()
 {
     m_bufferGeometryBeforeUpdateBlocking = bufferGeometry();
     m_frameGeometryBeforeUpdateBlocking = frameGeometry();
 }
 
 void AbstractClient::doMove(int, int)
 {
 }
 
 void AbstractClient::updateInitialMoveResizeGeometry()
 {
     m_moveResize.initialGeometry = frameGeometry();
     m_moveResize.geometry = m_moveResize.initialGeometry;
     m_moveResize.startScreen = screen();
 }
 
 void AbstractClient::updateCursor()
 {
     Position m = moveResizePointerMode();
     if (!isResizable() || isShade())
         m = PositionCenter;
     CursorShape c = Qt::ArrowCursor;
     switch(m) {
     case PositionTopLeft:
         c = KWin::ExtendedCursor::SizeNorthWest;
         break;
     case PositionBottomRight:
         c = KWin::ExtendedCursor::SizeSouthEast;
         break;
     case PositionBottomLeft:
         c = KWin::ExtendedCursor::SizeSouthWest;
         break;
     case PositionTopRight:
         c = KWin::ExtendedCursor::SizeNorthEast;
         break;
     case PositionTop:
         c = KWin::ExtendedCursor::SizeNorth;
         break;
     case PositionBottom:
         c = KWin::ExtendedCursor::SizeSouth;
         break;
     case PositionLeft:
         c = KWin::ExtendedCursor::SizeWest;
         break;
     case PositionRight:
         c = KWin::ExtendedCursor::SizeEast;
         break;
     default:
         if (isMoveResize())
             c = Qt::SizeAllCursor;
         else
             c = Qt::ArrowCursor;
         break;
     }
     if (c == m_moveResize.cursor)
         return;
     m_moveResize.cursor = c;
     emit moveResizeCursorChanged(c);
 }
 
 void AbstractClient::leaveMoveResize()
 {
     workspace()->setMoveResizeClient(nullptr);
     setMoveResize(false);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(false, Qt::Vertical|Qt::Horizontal);
     if (isElectricBorderMaximizing()) {
         outline()->hide();
         elevate(false);
     }
 }
 
 bool AbstractClient::s_haveResizeEffect = false;
 
 void AbstractClient::updateHaveResizeEffect()
 {
     s_haveResizeEffect = effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::Resize);
 }
 
 bool AbstractClient::doStartMoveResize()
 {
     return true;
 }
 
 void AbstractClient::positionGeometryTip()
 {
 }
 
 void AbstractClient::doPerformMoveResize()
 {
 }
 
 bool AbstractClient::isWaitingForMoveResizeSync() const
 {
     return false;
 }
 
 void AbstractClient::doResizeSync()
 {
 }
 
 void AbstractClient::checkQuickTilingMaximizationZones(int xroot, int yroot)
 {
     QuickTileMode mode = QuickTileFlag::None;
     bool innerBorder = false;
     for (int i=0; i < screens()->count(); ++i) {
 
         if (!screens()->geometry(i).contains(QPoint(xroot, yroot)))
             continue;
 
         auto isInScreen = [i](const QPoint &pt) {
             for (int j = 0; j < screens()->count(); ++j) {
                 if (j == i)
                     continue;
                 if (screens()->geometry(j).contains(pt)) {
                     return true;
                 }
             }
             return false;
         };
 
         QRect area = workspace()->clientArea(MaximizeArea, QPoint(xroot, yroot), desktop());
         if (options->electricBorderTiling()) {
             if (xroot <= area.x() + 20) {
                 mode |= QuickTileFlag::Left;
                 innerBorder = isInScreen(QPoint(area.x() - 1, yroot));
             } else if (xroot >= area.x() + area.width() - 20) {
                 mode |= QuickTileFlag::Right;
                 innerBorder = isInScreen(QPoint(area.right() + 1, yroot));
             }
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Top;
             else if (yroot >= area.y() + area.height() - area.height()  * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Bottom;
         } else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) {
             mode = QuickTileFlag::Maximize;
             innerBorder = isInScreen(QPoint(xroot, area.y() - 1));
         }
         break; // no point in checking other screens to contain this... "point"...
     }
     if (mode != electricBorderMode()) {
         setElectricBorderMode(mode);
         if (innerBorder) {
             if (!m_electricMaximizingDelay) {
                 m_electricMaximizingDelay = new QTimer(this);
                 m_electricMaximizingDelay->setInterval(250);
                 m_electricMaximizingDelay->setSingleShot(true);
                 connect(m_electricMaximizingDelay, &QTimer::timeout, [this]() {
                     if (isMove())
                         setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None));
                 });
             }
             m_electricMaximizingDelay->start();
         } else {
             setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None));
         }
     }
 }
 
 void AbstractClient::keyPressEvent(uint key_code)
 {
     if (!isMove() && !isResize())
         return;
     bool is_control = key_code & Qt::CTRL;
     bool is_alt = key_code & Qt::ALT;
     key_code = key_code & ~Qt::KeyboardModifierMask;
     int delta = is_control ? 1 : is_alt ? 32 : 8;
     QPoint pos = Cursor::pos();
     switch(key_code) {
     case Qt::Key_Left:
         pos.rx() -= delta;
         break;
     case Qt::Key_Right:
         pos.rx() += delta;
         break;
     case Qt::Key_Up:
         pos.ry() -= delta;
         break;
     case Qt::Key_Down:
         pos.ry() += delta;
         break;
     case Qt::Key_Space:
     case Qt::Key_Return:
     case Qt::Key_Enter:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(false);
         updateCursor();
         break;
     case Qt::Key_Escape:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(true);
         updateCursor();
         break;
     default:
         return;
     }
     Cursor::setPos(pos);
 }
 
 QSize AbstractClient::resizeIncrements() const
 {
     return QSize(1, 1);
 }
 
 void AbstractClient::dontMoveResize()
 {
     setMoveResizePointerButtonDown(false);
     stopDelayedMoveResize();
     if (isMoveResize())
         finishMoveResize(false);
 }
 
 AbstractClient::Position AbstractClient::mousePosition() const
 {
     if (isDecorated()) {
         switch (decoration()->sectionUnderMouse()) {
             case Qt::BottomLeftSection:
                 return PositionBottomLeft;
             case Qt::BottomRightSection:
                 return PositionBottomRight;
             case Qt::BottomSection:
                 return PositionBottom;
             case Qt::LeftSection:
                 return PositionLeft;
             case Qt::RightSection:
                 return PositionRight;
             case Qt::TopSection:
                 return PositionTop;
             case Qt::TopLeftSection:
                 return PositionTopLeft;
             case Qt::TopRightSection:
                 return PositionTopRight;
             default:
                 return PositionCenter;
         }
     }
     return PositionCenter;
 }
 
 void AbstractClient::endMoveResize()
 {
     setMoveResizePointerButtonDown(false);
     stopDelayedMoveResize();
     if (isMoveResize()) {
         finishMoveResize(false);
         setMoveResizePointerMode(mousePosition());
     }
     updateCursor();
 }
 
 void AbstractClient::destroyDecoration()
 {
     delete m_decoration.decoration;
     m_decoration.decoration = nullptr;
 }
 
 bool AbstractClient::decorationHasAlpha() const
 {
     if (!isDecorated() || decoration()->isOpaque()) {
         // either no decoration or decoration has alpha disabled
         return false;
     }
     return true;
 }
 
 void AbstractClient::triggerDecorationRepaint()
 {
     if (isDecorated()) {
         decoration()->update();
     }
 }
 
 void AbstractClient::layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const
 {
     if (!isDecorated()) {
         return;
     }
     QRect r = decoration()->rect();
 
     top = QRect(r.x(), r.y(), r.width(), borderTop());
     bottom = QRect(r.x(), r.y() + r.height() - borderBottom(),
                    r.width(), borderBottom());
     left = QRect(r.x(), r.y() + top.height(),
                  borderLeft(), r.height() - top.height() - bottom.height());
     right = QRect(r.x() + r.width() - borderRight(), r.y() + top.height(),
                   borderRight(), r.height() - top.height() - bottom.height());
 }
 
 void AbstractClient::processDecorationMove(const QPoint &localPos, const QPoint &globalPos)
 {
     if (isMoveResizePointerButtonDown()) {
         handleMoveResize(localPos.x(), localPos.y(), globalPos.x(), globalPos.y());
         return;
     }
     // TODO: handle modifiers
     Position newmode = mousePosition();
     if (newmode != moveResizePointerMode()) {
         setMoveResizePointerMode(newmode);
         updateCursor();
     }
 }
 
 bool AbstractClient::processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu)
 {
     Options::MouseCommand com = Options::MouseNothing;
     bool active = isActive();
     if (!wantsInput())    // we cannot be active, use it anyway
         active = true;
 
     // check whether it is a double click
     if (event->button() == Qt::LeftButton && titlebarPositionUnderMouse()) {
         if (m_decoration.doubleClickTimer.isValid()) {
             const qint64 interval = m_decoration.doubleClickTimer.elapsed();
             m_decoration.doubleClickTimer.invalidate();
             if (interval > QGuiApplication::styleHints()->mouseDoubleClickInterval()) {
                 m_decoration.doubleClickTimer.start(); // expired -> new first click and pot. init
             } else {
                 Workspace::self()->performWindowOperation(this, options->operationTitlebarDblClick());
                 dontMoveResize();
                 return false;
             }
         }
          else {
             m_decoration.doubleClickTimer.start(); // new first click and pot. init, could be invalidated by release - see below
         }
     }
 
     if (event->button() == Qt::LeftButton)
         com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();
     else if (event->button() == Qt::MidButton)
         com = active ? options->commandActiveTitlebar2() : options->commandInactiveTitlebar2();
     else if (event->button() == Qt::RightButton)
         com = active ? options->commandActiveTitlebar3() : options->commandInactiveTitlebar3();
     if (event->button() == Qt::LeftButton
             && com != Options::MouseOperationsMenu // actions where it's not possible to get the matching
             && com != Options::MouseMinimize)  // mouse release event
     {
         setMoveResizePointerMode(mousePosition());
         setMoveResizePointerButtonDown(true);
         setMoveOffset(event->pos());
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         startDelayedMoveResize();
         updateCursor();
     }
     // In the new API the decoration may process the menu action to display an inactive tab's menu.
     // If the event is unhandled then the core will create one for the active window in the group.
     if (!ignoreMenu || com != Options::MouseOperationsMenu)
         performMouseCommand(com, event->globalPos());
     return !( // Return events that should be passed to the decoration in the new API
                com == Options::MouseRaise ||
                com == Options::MouseOperationsMenu ||
                com == Options::MouseActivateAndRaise ||
                com == Options::MouseActivate ||
                com == Options::MouseActivateRaiseAndPassClick ||
                com == Options::MouseActivateAndPassClick ||
                com == Options::MouseNothing);
 }
 
 void AbstractClient::processDecorationButtonRelease(QMouseEvent *event)
 {
     if (isDecorated()) {
         if (event->isAccepted() || !titlebarPositionUnderMouse()) {
             invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
         }
     }
 
     if (event->buttons() == Qt::NoButton) {
         setMoveResizePointerButtonDown(false);
         stopDelayedMoveResize();
         if (isMoveResize()) {
             finishMoveResize(false);
             setMoveResizePointerMode(mousePosition());
         }
         updateCursor();
     }
 }
 
 
 void AbstractClient::startDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.start();
 }
 
 void AbstractClient::invalidateDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.invalidate();
 }
 
 bool AbstractClient::providesContextHelp() const
 {
     return false;
 }
 
 void AbstractClient::showContextHelp()
 {
 }
 
 QPointer<Decoration::DecoratedClientImpl> AbstractClient::decoratedClient() const
 {
     return m_decoration.client;
 }
 
 void AbstractClient::setDecoratedClient(QPointer< Decoration::DecoratedClientImpl > client)
 {
     m_decoration.client = client;
 }
 
 void AbstractClient::enterEvent(const QPoint &globalPos)
 {
     // TODO: shade hover
     if (options->focusPolicy() == Options::ClickToFocus || workspace()->userActionsMenu()->isShown())
         return;
 
     if (options->isAutoRaise() && !isDesktop() &&
             !isDock() && workspace()->focusChangeEnabled() &&
             globalPos != workspace()->focusMousePosition() &&
             workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(),
                                             options->isSeparateScreenFocus() ? screen() : -1) != this) {
         startAutoRaise();
     }
 
     if (isDesktop() || isDock())
         return;
     // for FocusFollowsMouse, change focus only if the mouse has actually been moved, not if the focus
     // change came because of window changes (e.g. closing a window) - #92290
     if (options->focusPolicy() != Options::FocusFollowsMouse
             || globalPos != workspace()->focusMousePosition()) {
         workspace()->requestDelayFocus(this);
     }
 }
 
 void AbstractClient::leaveEvent()
 {
     cancelAutoRaise();
     workspace()->cancelDelayFocus();
     // TODO: shade hover
     // TODO: send hover leave to deco
     // TODO: handle Options::FocusStrictlyUnderMouse
 }
 
 QRect AbstractClient::iconGeometry() const
 {
     if (!windowManagementInterface() || !waylandServer()) {
         // window management interface is only available if the surface is mapped
         return QRect();
     }
 
     int minDistance = INT_MAX;
     AbstractClient *candidatePanel = nullptr;
     QRect candidateGeom;
 
     for (auto i = windowManagementInterface()->minimizedGeometries().constBegin(), end = windowManagementInterface()->minimizedGeometries().constEnd(); i != end; ++i) {
-        AbstractClient *client = waylandServer()->findAbstractClient(i.key());
+        AbstractClient *client = waylandServer()->findClient(i.key());
         if (!client) {
             continue;
         }
         const int distance = QPoint(client->pos() - pos()).manhattanLength();
         if (distance < minDistance) {
             minDistance = distance;
             candidatePanel = client;
             candidateGeom = i.value();
         }
     }
     if (!candidatePanel) {
         return QRect();
     }
     return candidateGeom.translated(candidatePanel->pos());
 }
 
 QRect AbstractClient::inputGeometry() const
 {
     if (isDecorated()) {
         return Toplevel::inputGeometry() + decoration()->resizeOnlyBorders();
     }
     return Toplevel::inputGeometry();
 }
 
 QRect AbstractClient::virtualKeyboardGeometry() const
 {
     return m_virtualKeyboardGeometry;
 }
 
 void AbstractClient::setVirtualKeyboardGeometry(const QRect &geo)
 {
     // No keyboard anymore
     if (geo.isEmpty() && !m_keyboardGeometryRestore.isEmpty()) {
         setFrameGeometry(m_keyboardGeometryRestore);
         m_keyboardGeometryRestore = QRect();
     } else if (geo.isEmpty()) {
         return;
     // The keyboard has just been opened (rather than resized) save client geometry for a restore
     } else if (m_keyboardGeometryRestore.isEmpty()) {
         m_keyboardGeometryRestore = frameGeometry();
     }
 
     m_virtualKeyboardGeometry = geo;
 
     // Don't resize Desktop and fullscreen windows
     if (isFullScreen() || isDesktop()) {
         return;
     }
 
     if (!geo.intersects(m_keyboardGeometryRestore)) {
         return;
     }
 
     const QRect availableArea = workspace()->clientArea(MaximizeArea, this);
     QRect newWindowGeometry = m_keyboardGeometryRestore;
     newWindowGeometry.moveBottom(geo.top());
     newWindowGeometry.setTop(qMax(newWindowGeometry.top(), availableArea.top()));
 
     setFrameGeometry(newWindowGeometry);
 }
 
 bool AbstractClient::dockWantsInput() const
 {
     return false;
 }
 
 void AbstractClient::setDesktopFileName(QByteArray name)
 {
     name = rules()->checkDesktopFile(name).toUtf8();
     if (name == m_desktopFileName) {
         return;
     }
     m_desktopFileName = name;
     updateWindowRules(Rules::DesktopFile);
     emit desktopFileNameChanged();
 }
 
 QString AbstractClient::iconFromDesktopFile() const
 {
     if (m_desktopFileName.isEmpty()) {
         return QString();
     }
     QString desktopFile = QString::fromUtf8(m_desktopFileName);
     if (!desktopFile.endsWith(QLatin1String(".desktop"))) {
         desktopFile.append(QLatin1String(".desktop"));
     }
     KDesktopFile df(desktopFile);
     return df.readIcon();
 }
 
 bool AbstractClient::hasApplicationMenu() const
 {
     return ApplicationMenu::self()->applicationMenuEnabled() && !m_applicationMenuServiceName.isEmpty() && !m_applicationMenuObjectPath.isEmpty();
 }
 
 void AbstractClient::updateApplicationMenuServiceName(const QString &serviceName)
 {
     const bool old_hasApplicationMenu = hasApplicationMenu();
 
     m_applicationMenuServiceName = serviceName;
 
     const bool new_hasApplicationMenu = hasApplicationMenu();
 
     if (old_hasApplicationMenu != new_hasApplicationMenu) {
         emit hasApplicationMenuChanged(new_hasApplicationMenu);
     }
 }
 
 void AbstractClient::updateApplicationMenuObjectPath(const QString &objectPath)
 {
     const bool old_hasApplicationMenu = hasApplicationMenu();
 
     m_applicationMenuObjectPath = objectPath;
 
     const bool new_hasApplicationMenu = hasApplicationMenu();
 
     if (old_hasApplicationMenu != new_hasApplicationMenu) {
         emit hasApplicationMenuChanged(new_hasApplicationMenu);
     }
 }
 
 void AbstractClient::setApplicationMenuActive(bool applicationMenuActive)
 {
     if (m_applicationMenuActive != applicationMenuActive) {
         m_applicationMenuActive = applicationMenuActive;
         emit applicationMenuActiveChanged(applicationMenuActive);
     }
 }
 
 void AbstractClient::showApplicationMenu(int actionId)
 {
     if (isDecorated()) {
         decoration()->showApplicationMenu(actionId);
     } else {
         // we don't know where the application menu button will be, show it in the top left corner instead
         Workspace::self()->showApplicationMenu(QRect(), this, actionId);
     }
 }
 
 bool AbstractClient::unresponsive() const
 {
     return m_unresponsive;
 }
 
 void AbstractClient::setUnresponsive(bool unresponsive)
 {
     if (m_unresponsive != unresponsive) {
         m_unresponsive = unresponsive;
         emit unresponsiveChanged(m_unresponsive);
         emit captionChanged();
     }
 }
 
 QString AbstractClient::shortcutCaptionSuffix() const
 {
     if (shortcut().isEmpty()) {
         return QString();
     }
     return QLatin1String(" {") + shortcut().toString() + QLatin1Char('}');
 }
 
 AbstractClient *AbstractClient::findClientWithSameCaption() const
 {
     auto fetchNameInternalPredicate = [this](const AbstractClient *cl) {
         return (!cl->isSpecialWindow() || cl->isToolbar()) && cl != this && cl->captionNormal() == captionNormal() && cl->captionSuffix() == captionSuffix();
     };
     return workspace()->findAbstractClient(fetchNameInternalPredicate);
 }
 
 QString AbstractClient::caption() const
 {
     QString cap = captionNormal() + captionSuffix();
     if (unresponsive()) {
         cap += QLatin1String(" ");
         cap += i18nc("Application is not responding, appended to window title", "(Not Responding)");
     }
     return cap;
 }
 
 void AbstractClient::removeRule(Rules* rule)
 {
     m_rules.remove(rule);
 }
 
 void AbstractClient::discardTemporaryRules()
 {
     m_rules.discardTemporary();
 }
 
 void AbstractClient::evaluateWindowRules()
 {
     setupWindowRules(true);
     applyWindowRules();
 }
 
 void AbstractClient::setOnActivities(QStringList newActivitiesList)
 {
     Q_UNUSED(newActivitiesList)
 }
 
 void AbstractClient::checkNoBorder()
 {
     setNoBorder(false);
 }
 
 bool AbstractClient::groupTransient() const
 {
     return false;
 }
 
 const Group *AbstractClient::group() const
 {
     return nullptr;
 }
 
 Group *AbstractClient::group()
 {
     return nullptr;
 }
 
 bool AbstractClient::isInternal() const
 {
     return false;
 }
 
 bool AbstractClient::supportsWindowRules() const
 {
     return true;
 }
 
 QMargins AbstractClient::frameMargins() const
 {
     return QMargins(borderLeft(), borderTop(), borderRight(), borderBottom());
 }
 
 QPoint AbstractClient::framePosToClientPos(const QPoint &point) const
 {
     return point + QPoint(borderLeft(), borderTop());
 }
 
 QPoint AbstractClient::clientPosToFramePos(const QPoint &point) const
 {
     return point - QPoint(borderLeft(), borderTop());
 }
 
 QSize AbstractClient::frameSizeToClientSize(const QSize &size) const
 {
     const int width = size.width() - borderLeft() - borderRight();
     const int height = size.height() - borderTop() - borderBottom();
     return QSize(width, height);
 }
 
 QSize AbstractClient::clientSizeToFrameSize(const QSize &size) const
 {
     const int width = size.width() + borderLeft() + borderRight();
     const int height = size.height() + borderTop() + borderBottom();
     return QSize(width, height);
 }
 
 QRect AbstractClient::frameRectToClientRect(const QRect &rect) const
 {
     const QPoint position = framePosToClientPos(rect.topLeft());
     const QSize size = frameSizeToClientSize(rect.size());
     return QRect(position, size);
 }
 
 QRect AbstractClient::clientRectToFrameRect(const QRect &rect) const
 {
     const QPoint position = clientPosToFramePos(rect.topLeft());
     const QSize size = clientSizeToFrameSize(rect.size());
     return QRect(position, size);
 }
 
 void AbstractClient::setElectricBorderMode(QuickTileMode mode)
 {
     if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
         // sanitize the mode, ie. simplify "invalid" combinations
         if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
             mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
         if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
             mode &= ~QuickTileMode(QuickTileFlag::Vertical);
     }
     m_electricMode = mode;
 }
 
 void AbstractClient::setElectricBorderMaximizing(bool maximizing)
 {
     m_electricMaximizing = maximizing;
     if (maximizing)
         outline()->show(electricBorderMaximizeGeometry(Cursor::pos(), desktop()), moveResizeGeometry());
     else
         outline()->hide();
     elevate(maximizing);
 }
 
 QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop)
 {
     if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) {
         if (maximizeMode() == MaximizeFull)
             return geometryRestore();
         else
             return workspace()->clientArea(MaximizeArea, pos, desktop);
     }
 
     QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop);
     if (electricBorderMode() & QuickTileFlag::Left)
         ret.setRight(ret.left()+ret.width()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Right)
         ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1);
     if (electricBorderMode() & QuickTileFlag::Top)
         ret.setBottom(ret.top()+ret.height()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Bottom)
         ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1);
 
     return ret;
 }
 
 void AbstractClient::setQuickTileMode(QuickTileMode mode, bool keyboard)
 {
     // Only allow quick tile on a regular window.
     if (!isResizable()) {
         return;
     }
 
     workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
 
     GeometryUpdatesBlocker blocker(this);
 
     if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
         m_quickTileMode = int(QuickTileFlag::None);
         if (maximizeMode() == MaximizeFull) {
             setMaximize(false, false);
         } else {
             QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore
             m_quickTileMode = int(QuickTileFlag::Maximize);
             setMaximize(true, true);
             QRect clientArea = workspace()->clientArea(MaximizeArea, this);
             if (frameGeometry().top() != clientArea.top()) {
                 QRect r(frameGeometry());
                 r.moveTop(clientArea.top());
                 setFrameGeometry(r);
             }
             setGeometryRestore(prev_geom_restore);
         }
         emit quickTileModeChanged();
         return;
     }
 
     // sanitize the mode, ie. simplify "invalid" combinations
     if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
         mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
     if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
         mode &= ~QuickTileMode(QuickTileFlag::Vertical);
 
     setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
 
     // restore from maximized so that it is possible to tile maximized windows with one hit or by dragging
     if (maximizeMode() != MaximizeRestore) {
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused
 
             setMaximize(false, false);
 
             setFrameGeometry(electricBorderMaximizeGeometry(keyboard ? frameGeometry().center() : Cursor::pos(), desktop()), geom_mode);
             // Store the mode change
             m_quickTileMode = mode;
         } else {
             m_quickTileMode = mode;
             setMaximize(false, false);
         }
 
         emit quickTileModeChanged();
 
         return;
     }
 
     if (mode != QuickTileMode(QuickTileFlag::None)) {
         QPoint whichScreen = keyboard ? frameGeometry().center() : Cursor::pos();
 
         // If trying to tile to the side that the window is already tiled to move the window to the next
         // screen if it exists, otherwise toggle the mode (set QuickTileFlag::None)
         if (quickTileMode() == mode) {
             const int numScreens = screens()->count();
             const int curScreen = screen();
             int nextScreen = curScreen;
             QVarLengthArray<QRect> screens(numScreens);
             for (int i = 0; i < numScreens; ++i)   // Cache
                 screens[i] = Screens::self()->geometry(i);
             for (int i = 0; i < numScreens; ++i) {
 
                 if (i == curScreen)
                     continue;
 
                 if (screens[i].bottom() <= screens[curScreen].top() || screens[i].top() >= screens[curScreen].bottom())
                     continue; // not in horizontal line
 
                 const int x = screens[i].center().x();
                 if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) {
                     if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x()))
                         continue; // not left of current or more left then found next
                 } else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) {
                     if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x()))
                         continue; // not right of current or more right then found next
                 }
 
                 nextScreen = i;
             }
 
             if (nextScreen == curScreen) {
                 mode = QuickTileFlag::None; // No other screens, toggle tiling
             } else {
                 // Move to other screen
                 setFrameGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft()));
                 whichScreen = screens[nextScreen].center();
 
                 // Swap sides
                 if (mode & QuickTileFlag::Horizontal) {
                     mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical);
                 }
             }
             setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
             // Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile.
             // Store geometry first, so we can go out of this tile later.
             setGeometryRestore(frameGeometry());
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             m_quickTileMode = mode;
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             // Temporary, so the maximize code doesn't get all confused
             m_quickTileMode = int(QuickTileFlag::None);
             setFrameGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode);
         }
 
         // Store the mode change
         m_quickTileMode = mode;
     }
 
     if (mode == QuickTileMode(QuickTileFlag::None)) {
         m_quickTileMode = int(QuickTileFlag::None);
         // Untiling, so just restore geometry, and we're done.
         if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement
             setGeometryRestore(frameGeometry());
         // decorations may turn off some borders when tiled
         const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
         setFrameGeometry(geometryRestore(), geom_mode);
         checkWorkspacePosition(); // Just in case it's a different screen
     }
     emit quickTileModeChanged();
 }
 
 void AbstractClient::sendToScreen(int newScreen)
 {
     newScreen = rules()->checkScreen(newScreen);
     if (isActive()) {
         screens()->setCurrent(newScreen);
         // might impact the layer of a fullscreen window
         foreach (AbstractClient *cc, workspace()->allClientList()) {
             if (cc->isFullScreen() && cc->screen() == newScreen) {
                 cc->updateLayer();
             }
         }
     }
     if (screen() == newScreen)   // Don't use isOnScreen(), that's true even when only partially
         return;
 
     GeometryUpdatesBlocker blocker(this);
 
     // operating on the maximized / quicktiled window would leave the old geom_restore behind,
     // so we clear the state first
     MaximizeMode maxMode = maximizeMode();
     QuickTileMode qtMode = quickTileMode();
     if (maxMode != MaximizeRestore)
         maximize(MaximizeRestore);
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         setQuickTileMode(QuickTileFlag::None, true);
 
     QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this);
     QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop());
 
     // the window can have its center so that the position correction moves the new center onto
     // the old screen, what will tile it where it is. Ie. the screen is not changed
     // this happens esp. with electric border quicktiling
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         keepInArea(oldScreenArea);
 
     QRect oldGeom = frameGeometry();
     QRect newGeom = oldGeom;
     // move the window to have the same relative position to the center of the screen
     // (i.e. one near the middle of the right edge will also end up near the middle of the right edge)
     QPoint center = newGeom.center() - oldScreenArea.center();
     center.setX(center.x() * screenArea.width() / oldScreenArea.width());
     center.setY(center.y() * screenArea.height() / oldScreenArea.height());
     center += screenArea.center();
     newGeom.moveCenter(center);
     setFrameGeometry(newGeom);
 
     // If the window was inside the old screen area, explicitly make sure its inside also the new screen area.
     // Calling checkWorkspacePosition() should ensure that, but when moving to a small screen the window could
     // be big enough to overlap outside of the new screen area, making struts from other screens come into effect,
     // which could alter the resulting geometry.
     if (oldScreenArea.contains(oldGeom)) {
         keepInArea(screenArea);
     }
 
     // align geom_restore - checkWorkspacePosition operates on it
     setGeometryRestore(frameGeometry());
 
     checkWorkspacePosition(oldGeom);
 
     // re-align geom_restore to constrained geometry
     setGeometryRestore(frameGeometry());
 
     // finally reset special states
     // NOTICE that MaximizeRestore/QuickTileFlag::None checks are required.
     // eg. setting QuickTileFlag::None would break maximization
     if (maxMode != MaximizeRestore)
         maximize(maxMode);
     if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode())
         setQuickTileMode(qtMode, true);
 
     auto tso = workspace()->ensureStackingOrder(transients());
     for (auto it = tso.constBegin(), end = tso.constEnd(); it != end; ++it)
         (*it)->sendToScreen(newScreen);
 }
 
 void AbstractClient::checkWorkspacePosition(QRect oldGeometry, int oldDesktop, QRect oldClientGeometry)
 {
     enum { Left = 0, Top, Right, Bottom };
     const int border[4] = { borderLeft(), borderTop(), borderRight(), borderBottom() };
     if( !oldGeometry.isValid())
         oldGeometry = frameGeometry();
     if( oldDesktop == -2 )
         oldDesktop = desktop();
     if (!oldClientGeometry.isValid())
         oldClientGeometry = oldGeometry.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     if (isDesktop())
         return;
     if (isFullScreen()) {
         QRect area = workspace()->clientArea(FullScreenArea, this);
         if (frameGeometry() != area)
             setFrameGeometry(area);
         return;
     }
     if (isDock())
         return;
 
     if (maximizeMode() != MaximizeRestore) {
         // TODO update geom_restore?
         changeMaximize(false, false, true);   // adjust size
         const QRect screenArea = workspace()->clientArea(ScreenArea, this);
         QRect geom = frameGeometry();
         checkOffscreenPosition(&geom, screenArea);
         setFrameGeometry(geom);
         return;
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         setFrameGeometry(electricBorderMaximizeGeometry(frameGeometry().center(), desktop()));
         return;
     }
 
     // this can be true only if this window was mapped before KWin
     // was started - in such case, don't adjust position to workarea,
     // because the window already had its position, and if a window
     // with a strut altering the workarea would be managed in initialization
     // after this one, this window would be moved
     if (!workspace() || workspace()->initializing())
         return;
 
     // If the window was touching an edge before but not now move it so it is again.
     // Old and new maximums have different starting values so windows on the screen
     // edge will move when a new strut is placed on the edge.
     QRect oldScreenArea;
     if( workspace()->inUpdateClientArea()) {
         // we need to find the screen area as it was before the change
         oldScreenArea = QRect( 0, 0, workspace()->oldDisplayWidth(), workspace()->oldDisplayHeight());
         int distance = INT_MAX;
         foreach(const QRect &r, workspace()->previousScreenSizes()) {
             int d = r.contains( oldGeometry.center()) ? 0 : ( r.center() - oldGeometry.center()).manhattanLength();
             if( d < distance ) {
                 distance = d;
                 oldScreenArea = r;
             }
         }
     } else {
         oldScreenArea = workspace()->clientArea(ScreenArea, oldGeometry.center(), oldDesktop);
     }
     const QRect oldGeomTall = QRect(oldGeometry.x(), oldScreenArea.y(), oldGeometry.width(), oldScreenArea.height());   // Full screen height
     const QRect oldGeomWide = QRect(oldScreenArea.x(), oldGeometry.y(), oldScreenArea.width(), oldGeometry.height());   // Full screen width
     int oldTopMax = oldScreenArea.y();
     int oldRightMax = oldScreenArea.x() + oldScreenArea.width();
     int oldBottomMax = oldScreenArea.y() + oldScreenArea.height();
     int oldLeftMax = oldScreenArea.x();
     const QRect screenArea = workspace()->clientArea(ScreenArea, geometryRestore().center(), desktop());
     int topMax = screenArea.y();
     int rightMax = screenArea.x() + screenArea.width();
     int bottomMax = screenArea.y() + screenArea.height();
     int leftMax = screenArea.x();
     QRect newGeom = geometryRestore(); // geometry();
     QRect newClientGeom = newGeom.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     const QRect newGeomTall = QRect(newGeom.x(), screenArea.y(), newGeom.width(), screenArea.height());   // Full screen height
     const QRect newGeomWide = QRect(screenArea.x(), newGeom.y(), screenArea.width(), newGeom.height());   // Full screen width
     // Get the max strut point for each side where the window is (E.g. Highest point for
     // the bottom struts bounded by the window's left and right sides).
 
     // These 4 compute old bounds ...
     auto moveAreaFunc = workspace()->inUpdateClientArea() ?
                                 &Workspace::previousRestrictedMoveArea : //... the restricted areas changed
                                 &Workspace::restrictedMoveArea; //... when e.g. active desktop or screen changes
 
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaTop)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldTopMax = qMax(oldTopMax, rect.y() + rect.height());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaRight)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldRightMax = qMin(oldRightMax, rect.x());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaBottom)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldBottomMax = qMin(oldBottomMax, rect.y());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaLeft)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldLeftMax = qMax(oldLeftMax, rect.x() + rect.width());
     }
 
     // These 4 compute new bounds
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaTop)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             topMax = qMax(topMax, rect.y() + rect.height());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaRight)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             rightMax = qMin(rightMax, rect.x());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaBottom)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             bottomMax = qMin(bottomMax, rect.y());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaLeft)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             leftMax = qMax(leftMax, rect.x() + rect.width());
     }
 
 
     // Check if the sides were inside or touching but are no longer
     bool keep[4] = {false, false, false, false};
     bool save[4] = {false, false, false, false};
     int padding[4] = {0, 0, 0, 0};
     if (oldGeometry.x() >= oldLeftMax)
         save[Left] = newGeom.x() < leftMax;
     if (oldGeometry.x() == oldLeftMax)
         keep[Left] = newGeom.x() != leftMax;
     else if (oldClientGeometry.x() == oldLeftMax && newClientGeom.x() != leftMax) {
         padding[0] = border[Left];
         keep[Left] = true;
     }
     if (oldGeometry.y() >= oldTopMax)
         save[Top] = newGeom.y() < topMax;
     if (oldGeometry.y() == oldTopMax)
         keep[Top] = newGeom.y() != topMax;
     else if (oldClientGeometry.y() == oldTopMax && newClientGeom.y() != topMax) {
         padding[1] = border[Left];
         keep[Top] = true;
     }
     if (oldGeometry.right() <= oldRightMax - 1)
         save[Right] = newGeom.right() > rightMax - 1;
     if (oldGeometry.right() == oldRightMax - 1)
         keep[Right] = newGeom.right() != rightMax - 1;
     else if (oldClientGeometry.right() == oldRightMax - 1 && newClientGeom.right() != rightMax - 1) {
         padding[2] = border[Right];
         keep[Right] = true;
     }
     if (oldGeometry.bottom() <= oldBottomMax - 1)
         save[Bottom] = newGeom.bottom() > bottomMax - 1;
     if (oldGeometry.bottom() == oldBottomMax - 1)
         keep[Bottom] = newGeom.bottom() != bottomMax - 1;
     else if (oldClientGeometry.bottom() == oldBottomMax - 1 && newClientGeom.bottom() != bottomMax - 1) {
         padding[3] = border[Bottom];
         keep[Bottom] = true;
     }
 
     // if randomly touches opposing edges, do not favor either
     if (keep[Left] && keep[Right]) {
         keep[Left] = keep[Right] = false;
         padding[0] = padding[2] = 0;
     }
     if (keep[Top] && keep[Bottom]) {
         keep[Top] = keep[Bottom] = false;
         padding[1] = padding[3] = 0;
     }
 
     if (save[Left] || keep[Left])
         newGeom.moveLeft(qMax(leftMax, screenArea.x()) - padding[0]);
     if (padding[0] && screens()->intersecting(newGeom) > 1)
         newGeom.moveLeft(newGeom.left() + padding[0]);
     if (save[Top] || keep[Top])
         newGeom.moveTop(qMax(topMax, screenArea.y()) - padding[1]);
     if (padding[1] && screens()->intersecting(newGeom) > 1)
         newGeom.moveTop(newGeom.top() + padding[1]);
     if (save[Right] || keep[Right])
         newGeom.moveRight(qMin(rightMax - 1, screenArea.right()) + padding[2]);
     if (padding[2] && screens()->intersecting(newGeom) > 1)
         newGeom.moveRight(newGeom.right() - padding[2]);
     if (oldGeometry.x() >= oldLeftMax && newGeom.x() < leftMax)
         newGeom.setLeft(qMax(leftMax, screenArea.x()));
     else if (oldClientGeometry.x() >= oldLeftMax && newGeom.x() + border[Left] < leftMax) {
         newGeom.setLeft(qMax(leftMax, screenArea.x()) - border[Left]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setLeft(newGeom.left() + border[Left]);
     }
     if (save[Bottom] || keep[Bottom])
         newGeom.moveBottom(qMin(bottomMax - 1, screenArea.bottom()) + padding[3]);
     if (padding[3] && screens()->intersecting(newGeom) > 1)
         newGeom.moveBottom(newGeom.bottom() - padding[3]);
     if (oldGeometry.y() >= oldTopMax && newGeom.y() < topMax)
         newGeom.setTop(qMax(topMax, screenArea.y()));
     else if (oldClientGeometry.y() >= oldTopMax && newGeom.y() + border[Top] < topMax) {
         newGeom.setTop(qMax(topMax, screenArea.y()) - border[Top]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setTop(newGeom.top() + border[Top]);
     }
 
     checkOffscreenPosition(&newGeom, screenArea);
     // Obey size hints. TODO: We really should make sure it stays in the right place
     if (!isShade())
         newGeom.setSize(constrainFrameSize(newGeom.size()));
 
     if (newGeom != frameGeometry())
         setFrameGeometry(newGeom);
 }
 
 void AbstractClient::checkOffscreenPosition(QRect* geom, const QRect& screenArea)
 {
     if (geom->left() > screenArea.right()) {
         geom->moveLeft(screenArea.right() - screenArea.width()/4);
     } else if (geom->right() < screenArea.left()) {
         geom->moveRight(screenArea.left() + screenArea.width()/4);
     }
     if (geom->top() > screenArea.bottom()) {
         geom->moveTop(screenArea.bottom() - screenArea.height()/4);
     } else if (geom->bottom() < screenArea.top()) {
         geom->moveBottom(screenArea.top() + screenArea.width()/4);
     }
 }
 
 /**
  * Returns the appropriate frame size for the current client size.
  *
  * This is equivalent to clientSizeToFrameSize(constrainClientSize(clientSize())).
  */
 QSize AbstractClient::adjustedSize() const
 {
     return clientSizeToFrameSize(constrainClientSize(clientSize()));
 }
 
 /**
  * Constrains the client size @p size according to a set of the window's size hints.
  *
  * Default implementation applies only minimum and maximum size constraints.
  */
 QSize AbstractClient::constrainClientSize(const QSize &size, SizeMode mode) const
 {
     Q_UNUSED(mode)
 
     int width = size.width();
     int height = size.height();
 
     // When user is resizing the window, the move resize geometry may have negative width or
     // height. In which case, we need to set negative dimensions to reasonable values.
     if (width < 1) {
         width = 1;
     }
     if (height < 1) {
         height = 1;
     }
 
     const QSize minimumSize = minSize();
     const QSize maximumSize = maxSize();
 
     width = qBound(minimumSize.width(), width, maximumSize.width());
     height = qBound(minimumSize.height(), height, maximumSize.height());
 
     return QSize(width, height);
 }
 
 /**
  * Constrains the frame size @p size according to a set of the window's size hints.
  */
 QSize AbstractClient::constrainFrameSize(const QSize &size, SizeMode mode) const
 {
     const QSize unconstrainedClientSize = frameSizeToClientSize(size);
     const QSize constrainedClientSize = constrainClientSize(unconstrainedClientSize, mode);
     return clientSizeToFrameSize(constrainedClientSize);
 }
 
 /**
  * Returns @c true if the AbstractClient can be shown in full screen mode; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreenable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient is currently being shown in full screen mode; otherwise @c false.
  *
  * A client in full screen mode occupies the entire screen with no window frame around it.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreen() const
 {
     return false;
 }
 
 /**
  * Returns whether requests initiated by the user to enter or leave full screen mode are honored.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::userCanSetFullScreen() const
 {
     return false;
 }
 
 /**
  * Asks the AbstractClient to enter or leave full screen mode.
  *
  * Default implementation does nothing.
  *
  * @param set @c true if the AbstractClient has to be shown in full screen mode, otherwise @c false
  * @param user @c true if the request is initiated by the user, otherwise @c false
  */
 void AbstractClient::setFullScreen(bool set, bool user)
 {
     Q_UNUSED(set)
     Q_UNUSED(user)
 }
 
 /**
  * Returns @c true if the AbstractClient can be minimized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMinimizable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient can be maximized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMaximizable() const
 {
     return false;
 }
 
 /**
  * Returns the currently applied maximize mode.
  *
  * Default implementation returns MaximizeRestore.
  */
 MaximizeMode AbstractClient::maximizeMode() const
 {
     return MaximizeRestore;
 }
 
 /**
  * Returns the last requested maximize mode.
  *
  * On X11, this method always matches maximizeMode(). On Wayland, it is asynchronous.
  *
  * Default implementation matches maximizeMode().
  */
 MaximizeMode AbstractClient::requestedMaximizeMode() const
 {
     return maximizeMode();
 }
 
 /**
  * Returns the geometry of the AbstractClient before it was maximized or quick tiled.
  */
 QRect AbstractClient::geometryRestore() const
 {
     return m_maximizeGeometryRestore;
 }
 
 /**
  * Sets the geometry of the AbstractClient before it was maximized or quick tiled to @p rect.
  */
 void AbstractClient::setGeometryRestore(const QRect &rect)
 {
     m_maximizeGeometryRestore = rect;
 }
 
 /**
  * Toggles the maximized state along specified dimensions @p horizontal and @p vertical.
  *
  * If @p adjust is @c true, only frame geometry will be updated to match requestedMaximizeMode().
  *
  * Default implementation does nothing.
  */
 void AbstractClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     Q_UNUSED(horizontal)
     Q_UNUSED(vertical)
     Q_UNUSED(adjust)
 }
 
 }
diff --git a/abstract_client.h b/abstract_client.h
index ee5657683..b8c164285 100644
--- a/abstract_client.h
+++ b/abstract_client.h
@@ -1,1356 +1,1358 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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_ABSTRACT_CLIENT_H
 #define KWIN_ABSTRACT_CLIENT_H
 
 #include "toplevel.h"
 #include "options.h"
 #include "rules.h"
 #include "cursor.h"
 
 #include <memory>
 
 #include <QElapsedTimer>
 #include <QPointer>
 
 namespace KWayland
 {
 namespace Server
 {
 class PlasmaWindowInterface;
 }
 }
 
 namespace KDecoration2
 {
 class Decoration;
 }
 
 namespace KWin
 {
 class Group;
 
 namespace TabBox
 {
 class TabBoxClientImpl;
 }
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class DecorationPalette;
 }
 
 class KWIN_EXPORT AbstractClient : public Toplevel
 {
     Q_OBJECT
 
     /**
      * Whether this Client is fullScreen. A Client might either be fullScreen due to the _NET_WM property
      * or through a legacy support hack. The fullScreen state can only be changed if the Client does not
      * use the legacy hack. To be sure whether the state changed, connect to the notify signal.
      */
     Q_PROPERTY(bool fullScreen READ isFullScreen WRITE setFullScreen NOTIFY fullScreenChanged)
 
     /**
      * Whether the Client can be set to fullScreen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool fullScreenable READ isFullScreenable)
 
     /**
      * Whether this Client is active or not. Use Workspace::activateClient() to activate a Client.
      * @see Workspace::activateClient
      */
     Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)
 
     /**
      * The desktop this Client is on. If the Client is on all desktops the property has value -1.
      * This is a legacy property, use x11DesktopIds instead
      */
     Q_PROPERTY(int desktop READ desktop WRITE setDesktop NOTIFY desktopChanged)
 
     /**
      * Whether the Client is on all desktops. That is desktop is -1.
      */
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops WRITE setOnAllDesktops NOTIFY desktopChanged)
 
     /**
      * The x11 ids for all desktops this client is in. On X11 this list will always have a length of 1
      */
     Q_PROPERTY(QVector<uint> x11DesktopIds READ x11DesktopIds NOTIFY x11DesktopIdsChanged)
 
     /**
      * Indicates that the window should not be included on a taskbar.
      */
     Q_PROPERTY(bool skipTaskbar READ skipTaskbar WRITE setSkipTaskbar NOTIFY skipTaskbarChanged)
 
     /**
      * Indicates that the window should not be included on a Pager.
      */
     Q_PROPERTY(bool skipPager READ skipPager WRITE setSkipPager NOTIFY skipPagerChanged)
 
     /**
      * Whether the Client should be excluded from window switching effects.
      */
     Q_PROPERTY(bool skipSwitcher READ skipSwitcher WRITE setSkipSwitcher NOTIFY skipSwitcherChanged)
 
     /**
      * Whether the window can be closed by the user. The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool closeable READ isCloseable)
 
     Q_PROPERTY(QIcon icon READ icon NOTIFY iconChanged)
 
     /**
      * Whether the Client is set to be kept above other windows.
      */
     Q_PROPERTY(bool keepAbove READ keepAbove WRITE setKeepAbove NOTIFY keepAboveChanged)
 
     /**
      * Whether the Client is set to be kept below other windows.
      */
     Q_PROPERTY(bool keepBelow READ keepBelow WRITE setKeepBelow NOTIFY keepBelowChanged)
 
     /**
      * Whether the Client can be shaded. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool shadeable READ isShadeable)
 
     /**
      * Whether the Client is shaded.
      */
     Q_PROPERTY(bool shade READ isShade WRITE setShade NOTIFY shadeChanged)
 
     /**
      * Whether the Client can be minimized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool minimizable READ isMinimizable)
 
     /**
      * Whether the Client is minimized.
      */
     Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized NOTIFY minimizedChanged)
 
     /**
      * The optional geometry representing the minimized Client in e.g a taskbar.
      * See _NET_WM_ICON_GEOMETRY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(QRect iconGeometry READ iconGeometry)
 
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool specialWindow READ isSpecialWindow)
 
     /**
      * Whether window state _NET_WM_STATE_DEMANDS_ATTENTION is set. This state indicates that some
      * action in or with the window happened. For example, it may be set by the Window Manager if
      * the window requested activation but the Window Manager refused it, or the application may set
      * it if it finished some work. This state may be set by both the Client and the Window Manager.
      * It should be unset by the Window Manager when it decides the window got the required attention
      * (usually, that it got activated).
      */
     Q_PROPERTY(bool demandsAttention READ isDemandingAttention WRITE demandAttention NOTIFY demandsAttentionChanged)
 
     /**
      * The Caption of the Client. Read from WM_NAME property together with a suffix for hostname and shortcut.
      * To read only the caption as provided by WM_NAME, use the getter with an additional @c false value.
      */
     Q_PROPERTY(QString caption READ caption NOTIFY captionChanged)
 
     /**
      * Minimum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize minSize READ minSize)
 
     /**
      * Maximum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize maxSize READ maxSize)
 
     /**
      * Whether the Client can accept keyboard focus.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool wantsInput READ wantsInput)
 
     /**
      * Whether the Client is a transient Window to another Window.
      * @see transientFor
      */
     Q_PROPERTY(bool transient READ isTransient NOTIFY transientChanged)
 
     /**
      * The Client to which this Client is a transient if any.
      */
     Q_PROPERTY(KWin::AbstractClient *transientFor READ transientFor NOTIFY transientChanged)
 
     /**
      * Whether the Client represents a modal window.
      */
     Q_PROPERTY(bool modal READ isModal NOTIFY modalChanged)
 
     /**
      * The geometry of this Client. Be aware that depending on resize mode the frameGeometryChanged
      * signal might be emitted at each resize step or only at the end of the resize operation.
      */
     Q_PROPERTY(QRect geometry READ frameGeometry WRITE setFrameGeometry)
 
     /**
      * Whether the Client is currently being moved by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool move READ isMove NOTIFY moveResizedChanged)
 
     /**
      * Whether the Client is currently being resized by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool resize READ isResize NOTIFY moveResizedChanged)
 
     /**
      * Whether the decoration is currently using an alpha channel.
      */
     Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
 
     /**
      * Whether the window has a decoration or not.
      * This property is not allowed to be set by applications themselves.
      * The decision whether a window has a border or not belongs to the window manager.
      * If this property gets abused by application developers, it will be removed again.
      */
     Q_PROPERTY(bool noBorder READ noBorder WRITE setNoBorder)
 
     /**
      * Whether the Client provides context help. Mostly needed by decorations to decide whether to
      * show the help button or not.
      */
     Q_PROPERTY(bool providesContextHelp READ providesContextHelp CONSTANT)
 
     /**
      * Whether the Client can be maximized both horizontally and vertically.
      * The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool maximizable READ isMaximizable)
 
     /**
      * Whether the Client is moveable. Even if it is not moveable, it might be possible to move
      * it to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveableAcrossScreens
      */
     Q_PROPERTY(bool moveable READ isMovable)
 
     /**
      * Whether the Client can be moved to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveable
      */
     Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
 
     /**
      * Whether the Client can be resized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool resizeable READ isResizable)
 
     /**
      * The desktop file name of the application this AbstractClient belongs to.
      *
      * This is either the base name without full path and without file extension of the
      * desktop file for the window's application (e.g. "org.kde.foo").
      *
      * The application's desktop file name can also be the full path to the desktop file
      * (e.g. "/opt/kde/share/org.kde.foo.desktop") in case it's not in a standard location.
      */
     Q_PROPERTY(QByteArray desktopFileName READ desktopFileName NOTIFY desktopFileNameChanged)
 
     /**
      * Whether an application menu is available for this Client
      */
     Q_PROPERTY(bool hasApplicationMenu READ hasApplicationMenu NOTIFY hasApplicationMenuChanged)
 
     /**
      * Whether the application menu for this Client is currently opened
      */
     Q_PROPERTY(bool applicationMenuActive READ applicationMenuActive NOTIFY applicationMenuActiveChanged)
 
     /**
      * Whether this client is unresponsive.
      *
      * When an application failed to react on a ping request in time, it is
      * considered unresponsive. This usually indicates that the application froze or crashed.
      */
     Q_PROPERTY(bool unresponsive READ unresponsive NOTIFY unresponsiveChanged)
 
     /**
      * The color scheme set on this client
      * Absolute file path, or name of palette in the user's config directory following KColorSchemes format.
      * An empty string indicates the default palette from kdeglobals is used.
      * @note this indicates the colour scheme requested, which might differ from the theme applied if the colorScheme cannot be found
      */
     Q_PROPERTY(QString colorScheme READ colorScheme NOTIFY colorSchemeChanged)
 
 public:
     ~AbstractClient() override;
 
     QWeakPointer<TabBox::TabBoxClientImpl> tabBoxClient() const {
         return m_tabBoxClient.toWeakRef();
     }
     bool isFirstInTabBox() const {
         return m_firstInTabBox;
     }
     bool skipSwitcher() const {
         return m_skipSwitcher;
     }
     void setSkipSwitcher(bool set);
 
     bool skipTaskbar() const {
         return m_skipTaskbar;
     }
     void setSkipTaskbar(bool set);
     void setOriginalSkipTaskbar(bool set);
     bool originalSkipTaskbar() const {
         return m_originalSkipTaskbar;
     }
 
     bool skipPager() const {
         return m_skipPager;
     }
     void setSkipPager(bool set);
 
     const QIcon &icon() const {
         return m_icon;
     }
 
     bool isActive() const {
         return m_active;
     }
     /**
      * Sets the client's active state to \a act.
      *
      * This function does only change the visual appearance of the client,
      * it does not change the focus setting. Use
      * Workspace::activateClient() or Workspace::requestFocus() instead.
      *
      * If a client receives or looses the focus, it calls setActive() on
      * its own.
      */
     void setActive(bool);
 
     bool keepAbove() const {
         return m_keepAbove;
     }
     void setKeepAbove(bool);
     bool keepBelow() const {
         return m_keepBelow;
     }
     void setKeepBelow(bool);
 
     void demandAttention(bool set = true);
     bool isDemandingAttention() const {
         return m_demandsAttention;
     }
 
     void cancelAutoRaise();
 
     bool wantsTabFocus() const;
 
     QMargins frameMargins() const override;
     QPoint clientPos() const override {
         return QPoint(borderLeft(), borderTop());
     }
 
     virtual void updateMouseGrab();
     /**
      * @returns The caption consisting of captionNormal and captionSuffix
      * @see captionNormal
      * @see captionSuffix
      */
     QString caption() const;
     /**
      * @returns The caption as set by the AbstractClient without any suffix.
      * @see caption
      * @see captionSuffix
      */
     virtual QString captionNormal() const = 0;
     /**
      * @returns The suffix added to the caption (e.g. shortcut, machine name, etc.)
      * @see caption
      * @see captionNormal
      */
     virtual QString captionSuffix() const = 0;
     virtual bool isCloseable() const = 0;
     // TODO: remove boolean trap
     virtual bool isShown(bool shaded_is_shown) const = 0;
     virtual bool isHiddenInternal() const = 0;
     // TODO: remove boolean trap
     virtual void hideClient(bool hide) = 0;
     virtual bool isFullScreenable() const;
     virtual bool isFullScreen() const;
     // TODO: remove boolean trap
     virtual AbstractClient *findModal(bool allow_itself = false) = 0;
     virtual bool isTransient() const;
     /**
      * @returns Whether there is a hint available to place the AbstractClient on it's parent, default @c false.
      * @see transientPlacementHint
      */
     virtual bool hasTransientPlacementHint() const;
     /**
      * Only valid id hasTransientPlacementHint is true
      * @returns The position the transient wishes to position itself
      */
     virtual QRect transientPlacement(const QRect &bounds) const;
     const AbstractClient* transientFor() const;
     AbstractClient* transientFor();
     /**
      * @returns @c true if c is the transient_for window for this client,
      *  or recursively the transient_for window
      * @todo: remove boolean trap
      */
     virtual bool hasTransient(const AbstractClient* c, bool indirect) const;
     const QList<AbstractClient*>& transients() const; // Is not indirect
+    virtual void addTransient(AbstractClient *client);
     virtual void removeTransient(AbstractClient* cl);
     virtual QList<AbstractClient*> mainClients() const; // Call once before loop , is not indirect
     QList<AbstractClient*> allMainClients() const; // Call once before loop , is indirect
     /**
      * Returns true for "special" windows and false for windows which are "normal"
      * (normal=window which has a border, can be moved by the user, can be closed, etc.)
      * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
      * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
      */
     bool isSpecialWindow() const;
     void sendToScreen(int screen);
     const QKeySequence &shortcut() const {
         return _shortcut;
     }
     void setShortcut(const QString &cut);
     virtual bool performMouseCommand(Options::MouseCommand, const QPoint &globalPos);
     void setOnAllDesktops(bool set);
     void setDesktop(int);
     void enterDesktop(VirtualDesktop *desktop);
     void leaveDesktop(VirtualDesktop *desktop);
 
     /**
      * Set the window as being on the attached list of desktops
      * On X11 it will be set to the last entry
      */
     void setDesktops(QVector<VirtualDesktop *> desktops);
 
     int desktop() const override {
         return m_desktops.isEmpty() ? (int)NET::OnAllDesktops : m_desktops.last()->x11DesktopNumber();
     }
     QVector<VirtualDesktop *> desktops() const override {
         return m_desktops;
     }
     QVector<uint> x11DesktopIds() const;
 
     void setMinimized(bool set);
     /**
      * Minimizes this client plus its transients
      */
     void minimize(bool avoid_animation = false);
     void unminimize(bool avoid_animation = false);
     bool isMinimized() const {
         return m_minimized;
     }
     virtual void setFullScreen(bool set, bool user = true);
 
     virtual void setClientShown(bool shown);
 
     QRect geometryRestore() const;
     virtual MaximizeMode maximizeMode() const;
     virtual MaximizeMode requestedMaximizeMode() const;
     void maximize(MaximizeMode);
     /**
      * Sets the maximization according to @p vertically and @p horizontally.
      */
     Q_INVOKABLE void setMaximize(bool vertically, bool horizontally);
     virtual bool noBorder() const = 0;
     virtual void setNoBorder(bool set) = 0;
     virtual void blockActivityUpdates(bool b = true) = 0;
     QPalette palette() const;
     const Decoration::DecorationPalette *decorationPalette() const;
     /**
      * Returns whether the window is resizable or has a fixed size.
      */
     virtual bool isResizable() const = 0;
     /**
      * Returns whether the window is moveable or has a fixed position.
      */
     virtual bool isMovable() const = 0;
     /**
      * Returns whether the window can be moved to another screen.
      */
     virtual bool isMovableAcrossScreens() const = 0;
     /**
      * @c true only for @c ShadeNormal
      */
     bool isShade() const {
         return shadeMode() == ShadeNormal;
     }
     /**
      * Default implementation returns @c ShadeNone
      */
     virtual ShadeMode shadeMode() const; // Prefer isShade()
     void setShade(bool set);
     /**
      * Default implementation does nothing
      */
     virtual void setShade(ShadeMode mode);
     /**
      * Whether the Client can be shaded. Default implementation returns @c false.
      */
     virtual bool isShadeable() const;
     virtual bool isMaximizable() const;
     virtual bool isMinimizable() const;
     virtual QRect iconGeometry() const;
     virtual bool userCanSetFullScreen() const;
     virtual bool userCanSetNoBorder() const = 0;
     virtual void checkNoBorder();
     virtual void setOnActivities(QStringList newActivitiesList);
     virtual void setOnAllActivities(bool set) = 0;
     const WindowRules* rules() const {
         return &m_rules;
     }
     void removeRule(Rules* r);
     void setupWindowRules(bool ignore_temporary);
     void evaluateWindowRules();
     virtual void applyWindowRules();
     virtual void takeFocus() = 0;
     virtual bool wantsInput() const = 0;
     /**
      * Whether a dock window wants input.
      *
      * By default KWin doesn't pass focus to a dock window unless a force activate
      * request is provided.
      *
      * This method allows to have dock windows take focus also through flags set on
      * the window.
      *
      * The default implementation returns @c false.
      */
     virtual bool dockWantsInput() const;
     void checkWorkspacePosition(QRect oldGeometry = QRect(), int oldDesktop = -2,  QRect oldClientGeometry = QRect());
     virtual xcb_timestamp_t userTime() const;
     virtual void updateWindowRules(Rules::Types selection);
 
     void growHorizontal();
     void shrinkHorizontal();
     void growVertical();
     void shrinkVertical();
     void updateMoveResize(const QPointF &currentGlobalCursor);
     /**
      * Ends move resize when all pointer buttons are up again.
      */
     void endMoveResize();
     void keyPressEvent(uint key_code);
 
     void enterEvent(const QPoint &globalPos);
     void leaveEvent();
 
     /**
      * These values represent positions inside an area
      */
     enum Position {
         // without prefix, they'd conflict with Qt::TopLeftCorner etc. :(
         PositionCenter         = 0x00,
         PositionLeft           = 0x01,
         PositionRight          = 0x02,
         PositionTop            = 0x04,
         PositionBottom         = 0x08,
         PositionTopLeft        = PositionLeft | PositionTop,
         PositionTopRight       = PositionRight | PositionTop,
         PositionBottomLeft     = PositionLeft | PositionBottom,
         PositionBottomRight    = PositionRight | PositionBottom
     };
     Position titlebarPosition() const;
     bool titlebarPositionUnderMouse() const;
 
     // a helper for the workspace window packing. tests for screen validity and updates since in maximization case as with normal moving
     void packTo(int left, int top);
 
     /**
      * Sets the quick tile mode ("snap") of this window.
      * This will also handle preserving and restoring of window geometry as necessary.
      * @param mode The tile mode (left/right) to give this window.
      * @param keyboard Defines whether to take keyboard cursor into account.
      */
     void setQuickTileMode(QuickTileMode mode, bool keyboard = false);
     QuickTileMode quickTileMode() const {
         return QuickTileMode(m_quickTileMode);
     }
     Layer layer() const override;
     void updateLayer();
 
+    void placeIn(const QRect &area);
+
     enum ForceGeometry_t { NormalGeometrySet, ForceGeometrySet };
     virtual void move(int x, int y, ForceGeometry_t force = NormalGeometrySet);
     void move(const QPoint &p, ForceGeometry_t force = NormalGeometrySet);
     virtual void resizeWithChecks(int w, int h, ForceGeometry_t force = NormalGeometrySet) = 0;
     void resizeWithChecks(const QSize& s, ForceGeometry_t force = NormalGeometrySet);
     void keepInArea(QRect area, bool partial = false);
     virtual QSize minSize() const;
     virtual QSize maxSize() const;
     virtual void setFrameGeometry(int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet) = 0;
     void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet);
 
     /**
      * How to resize the window in order to obey constraints (mainly aspect ratios).
      */
     enum SizeMode {
         SizeModeAny,
         SizeModeFixedW, ///< Try not to affect width
         SizeModeFixedH, ///< Try not to affect height
         SizeModeMax ///< Try not to make it larger in either direction
     };
 
     virtual QSize constrainClientSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize constrainFrameSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize adjustedSize() const;
 
     /**
      * Calculates the matching client position for the given frame position @p point.
      */
     virtual QPoint framePosToClientPos(const QPoint &point) const;
     /**
      * Calculates the matching frame position for the given client position @p point.
      */
     virtual QPoint clientPosToFramePos(const QPoint &point) const;
     /**
      * Calculates the matching client size for the given frame size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the frame size with frame margins being excluded.
      */
     virtual QSize frameSizeToClientSize(const QSize &size) const;
     /**
      * Calculates the matching frame size for the given client size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the client size with frame margins being included.
      */
     virtual QSize clientSizeToFrameSize(const QSize &size) const;
     /**
      * Calculates the matching client rect for the given frame rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect frameRectToClientRect(const QRect &rect) const;
     /**
      * Calculates the matching frame rect for the given client rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect clientRectToFrameRect(const QRect &rect) const;
 
     /**
      * Returns @c true if the Client is being interactively moved; otherwise @c false.
      */
     bool isMove() const {
         return isMoveResize() && moveResizePointerMode() == PositionCenter;
     }
     /**
      * Returns @c true if the Client is being interactively resized; otherwise @c false.
      */
     bool isResize() const {
         return isMoveResize() && moveResizePointerMode() != PositionCenter;
     }
     /**
      * Cursor shape for move/resize mode.
      */
     CursorShape cursor() const {
         return m_moveResize.cursor;
     }
 
     virtual bool hasStrut() const;
 
     void setModal(bool modal);
     bool isModal() const;
 
     /**
      * Determines the mouse command for the given @p button in the current state.
      *
      * The @p handled argument specifies whether the button was handled or not.
      * This value should be used to determine whether the mouse button should be
      * passed to the AbstractClient or being filtered out.
      */
     Options::MouseCommand getMouseCommand(Qt::MouseButton button, bool *handled) const;
     Options::MouseCommand getWheelCommand(Qt::Orientation orientation, bool *handled) const;
 
     // decoration related
     KDecoration2::Decoration *decoration() {
         return m_decoration.decoration;
     }
     const KDecoration2::Decoration *decoration() const {
         return m_decoration.decoration;
     }
     bool isDecorated() const {
         return m_decoration.decoration != nullptr;
     }
     QPointer<Decoration::DecoratedClientImpl> decoratedClient() const;
     void setDecoratedClient(QPointer<Decoration::DecoratedClientImpl> client);
     bool decorationHasAlpha() const;
     void triggerDecorationRepaint();
     virtual void layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const;
     void processDecorationMove(const QPoint &localPos, const QPoint &globalPos);
     bool processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu = false);
     void processDecorationButtonRelease(QMouseEvent *event);
 
     /**
      * TODO: fix boolean traps
      */
     virtual void updateDecoration(bool check_workspace_pos, bool force = false) = 0;
 
     /**
      * Returns whether the window provides context help or not. If it does,
      * you should show a help menu item or a help button like '?' and call
      * contextHelp() if this is invoked.
      *
      * Default implementation returns @c false.
      * @see showContextHelp;
      */
     virtual bool providesContextHelp() const;
 
     /**
      * Invokes context help on the window. Only works if the window
      * actually provides context help.
      *
      * Default implementation does nothing.
      *
      * @see providesContextHelp()
      */
     virtual void showContextHelp();
 
     QRect inputGeometry() const override;
 
     /**
      * @returns the geometry of the virtual keyboard
      * This geometry is in global coordinates
      */
     QRect virtualKeyboardGeometry() const;
 
     /**
      * Sets the geometry of the virtual keyboard, The window may resize itself in order to make space for the keybaord
      * This geometry is in global coordinates
      */
     void setVirtualKeyboardGeometry(const QRect &geo);
 
     /**
      * Restores the AbstractClient after it had been hidden due to show on screen edge functionality.
      * The AbstractClient also gets raised (e.g. Panel mode windows can cover) and the AbstractClient
      * gets informed in a window specific way that it is shown and raised again.
      */
     virtual void showOnScreenEdge() = 0;
 
     QByteArray desktopFileName() const {
         return m_desktopFileName;
     }
 
     /**
      * Tries to terminate the process of this AbstractClient.
      *
      * Implementing subclasses can perform a windowing system solution for terminating.
      */
     virtual void killWindow() = 0;
 
     enum class SameApplicationCheck {
         RelaxedForActive = 1 << 0,
         AllowCrossProcesses = 1 << 1
     };
     Q_DECLARE_FLAGS(SameApplicationChecks, SameApplicationCheck)
     static bool belongToSameApplication(const AbstractClient* c1, const AbstractClient* c2, SameApplicationChecks checks = SameApplicationChecks());
 
     bool hasApplicationMenu() const;
     bool applicationMenuActive() const {
         return m_applicationMenuActive;
     }
     void setApplicationMenuActive(bool applicationMenuActive);
 
     QString applicationMenuServiceName() const {
         return m_applicationMenuServiceName;
     }
     QString applicationMenuObjectPath() const {
         return m_applicationMenuObjectPath;
     }
     QString colorScheme() const {
         return m_colorScheme;
     }
 
     /**
      * Request showing the application menu bar
      * @param actionId The DBus menu ID of the action that should be highlighted, 0 for the root menu
      */
     void showApplicationMenu(int actionId);
 
     bool unresponsive() const;
 
     virtual bool isInitialPositionSet() const {
         return false;
     }
 
     /**
      * Default implementation returns @c null.
      * Mostly intended for X11 clients, from EWMH:
      * @verbatim
      * If the WM_TRANSIENT_FOR property is set to None or Root window, the window should be
      * treated as a transient for all other windows in the same group. It has been noted that this
      * is a slight ICCCM violation, but as this behavior is pretty standard for many toolkits and
      * window managers, and is extremely unlikely to break anything, it seems reasonable to document
      * it as standard.
      * @endverbatim
      */
     virtual bool groupTransient() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual const Group *group() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual Group *group();
 
     /**
      * Returns whether this is an internal client.
      *
      * Internal clients are created by KWin and used for special purpose windows,
      * like the task switcher, etc.
      *
      * Default implementation returns @c false.
      */
     virtual bool isInternal() const;
 
     /**
      * Returns whether window rules can be applied to this client.
      *
      * Default implementation returns @c true.
      */
     virtual bool supportsWindowRules() const;
 
 public Q_SLOTS:
     virtual void closeWindow() = 0;
 
 Q_SIGNALS:
     void fullScreenChanged();
     void skipTaskbarChanged();
     void skipPagerChanged();
     void skipSwitcherChanged();
     void iconChanged();
     void activeChanged();
     void keepAboveChanged(bool);
     void keepBelowChanged(bool);
     /**
      * Emitted whenever the demands attention state changes.
      */
     void demandsAttentionChanged();
     void desktopPresenceChanged(KWin::AbstractClient*, int); // to be forwarded by Workspace
     void desktopChanged();
     void x11DesktopIdsChanged();
     void shadeChanged();
     void minimizedChanged();
     void clientMinimized(KWin::AbstractClient* client, bool animate);
     void clientUnminimized(KWin::AbstractClient* client, bool animate);
     void paletteChanged(const QPalette &p);
     void colorSchemeChanged();
     void captionChanged();
     void clientMaximizedStateChanged(KWin::AbstractClient*, MaximizeMode);
     void clientMaximizedStateChanged(KWin::AbstractClient* c, bool h, bool v);
     void transientChanged();
     void modalChanged();
     void quickTileModeChanged();
     void moveResizedChanged();
     void moveResizeCursorChanged(CursorShape);
     void clientStartUserMovedResized(KWin::AbstractClient*);
     void clientStepUserMovedResized(KWin::AbstractClient *, const QRect&);
     void clientFinishUserMovedResized(KWin::AbstractClient*);
     void closeableChanged(bool);
     void minimizeableChanged(bool);
     void shadeableChanged(bool);
     void maximizeableChanged(bool);
     void desktopFileNameChanged();
     void hasApplicationMenuChanged(bool);
     void applicationMenuActiveChanged(bool);
     void unresponsiveChanged(bool);
 
 protected:
     AbstractClient();
     void setFirstInTabBox(bool enable) {
         m_firstInTabBox = enable;
     }
     void setIcon(const QIcon &icon);
     void startAutoRaise();
     void autoRaise();
     /**
      * Whether the window accepts focus.
      * The difference to wantsInput is that the implementation should not check rules and return
      * what the window effectively supports.
      */
     virtual bool acceptsFocus() const = 0;
     /**
      * Called from setActive once the active value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetActive();
     /**
      * Called from setKeepAbove once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepAbove();
     /**
      * Called from setKeepBelow once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepBelow();
     /**
      * Called from setDeskop once the desktop value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetDesktop();
     /**
      * Called from @ref minimize and @ref unminimize once the minimized value got updated, but before the
      * changed signal is emitted.
      *
      * Default implementation does nothig.
      */
     virtual void doMinimize();
     virtual bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const = 0;
 
     virtual void doSetSkipTaskbar();
     virtual void doSetSkipPager();
     virtual void doSetSkipSwitcher();
     virtual void doSetDemandsAttention();
 
     void setupWindowManagementInterface();
     void destroyWindowManagementInterface();
 
     void updateColorScheme(QString path);
     virtual void updateColorScheme() = 0;
 
     void setTransientFor(AbstractClient *transientFor);
-    virtual void addTransient(AbstractClient* cl);
     /**
      * Just removes the @p cl from the transients without any further checks.
      */
     void removeTransientFromList(AbstractClient* cl);
 
     Layer belongsToLayer() const;
     virtual bool belongsToDesktop() const;
     void invalidateLayer();
     bool isActiveFullScreen() const;
     virtual Layer layerForDock() const;
 
     // electric border / quick tiling
     void setElectricBorderMode(QuickTileMode mode);
     QuickTileMode electricBorderMode() const {
         return m_electricMode;
     }
     void setElectricBorderMaximizing(bool maximizing);
     bool isElectricBorderMaximizing() const {
         return m_electricMaximizing;
     }
     QRect electricBorderMaximizeGeometry(QPoint pos, int desktop);
     void updateQuickTileMode(QuickTileMode newMode) {
         m_quickTileMode = newMode;
     }
 
     KWayland::Server::PlasmaWindowInterface *windowManagementInterface() const {
         return m_windowManagementInterface;
     }
 
     // geometry handling
     void checkOffscreenPosition(QRect *geom, const QRect &screenArea);
     int borderLeft() const;
     int borderRight() const;
     int borderTop() const;
     int borderBottom() const;
     virtual void changeMaximize(bool horizontal, bool vertical, bool adjust);
     void setGeometryRestore(const QRect &rect);
 
     /**
      * Called from move after updating the geometry. Can be reimplemented to perform specific tasks.
      * The base implementation does nothing.
      */
     virtual void doMove(int x, int y);
     void blockGeometryUpdates(bool block);
     void blockGeometryUpdates();
     void unblockGeometryUpdates();
     bool areGeometryUpdatesBlocked() const;
     enum PendingGeometry_t {
         PendingGeometryNone,
         PendingGeometryNormal,
         PendingGeometryForced
     };
     PendingGeometry_t pendingGeometryUpdate() const;
     void setPendingGeometryUpdate(PendingGeometry_t update);
     QRect bufferGeometryBeforeUpdateBlocking() const;
     QRect frameGeometryBeforeUpdateBlocking() const;
     void updateGeometryBeforeUpdateBlocking();
     /**
      * Schedules a repaint for the visibleRect before and after a
      * geometry update. The current visibleRect is stored for the
      * next time this method is called as the before geometry.
      */
     void addRepaintDuringGeometryUpdates();
 
     /**
      * @returns whether the Client is currently in move resize mode
      */
     bool isMoveResize() const {
         return m_moveResize.enabled;
     }
     /**
      * Sets whether the Client is in move resize mode to @p enabled.
      */
     void setMoveResize(bool enabled) {
         m_moveResize.enabled = enabled;
     }
     /**
      * @returns whether the move resize mode is unrestricted.
      */
     bool isUnrestrictedMoveResize() const {
         return m_moveResize.unrestricted;
     }
     /**
      * Sets whether move resize mode is unrestricted to @p set.
      */
     void setUnrestrictedMoveResize(bool set) {
         m_moveResize.unrestricted = set;
     }
     QPoint moveOffset() const {
         return m_moveResize.offset;
     }
     void setMoveOffset(const QPoint &offset) {
         m_moveResize.offset = offset;
     }
     QPoint invertedMoveOffset() const {
         return m_moveResize.invertedOffset;
     }
     void setInvertedMoveOffset(const QPoint &offset) {
         m_moveResize.invertedOffset = offset;
     }
     QRect initialMoveResizeGeometry() const {
         return m_moveResize.initialGeometry;
     }
     /**
      * Sets the initial move resize geometry to the current geometry.
      */
     void updateInitialMoveResizeGeometry();
     QRect moveResizeGeometry() const {
         return m_moveResize.geometry;
     }
     void setMoveResizeGeometry(const QRect &geo) {
         m_moveResize.geometry = geo;
     }
     Position moveResizePointerMode() const {
         return m_moveResize.pointer;
     }
     void setMoveResizePointerMode(Position mode) {
         m_moveResize.pointer = mode;
     }
     bool isMoveResizePointerButtonDown() const {
         return m_moveResize.buttonDown;
     }
     void setMoveResizePointerButtonDown(bool down) {
         m_moveResize.buttonDown = down;
     }
     int moveResizeStartScreen() const {
         return m_moveResize.startScreen;
     }
     void checkUnrestrictedMoveResize();
     /**
      * Sets an appropriate cursor shape for the logical mouse position.
      */
     void updateCursor();
     void startDelayedMoveResize();
     void stopDelayedMoveResize();
     bool startMoveResize();
     /**
      * Called from startMoveResize.
      *
      * Implementing classes should return @c false if starting move resize should
      * get aborted. In that case startMoveResize will also return @c false.
      *
      * Base implementation returns @c true.
      */
     virtual bool doStartMoveResize();
     void finishMoveResize(bool cancel);
     /**
      * Leaves the move resize mode.
      *
      * Inheriting classes must invoke the base implementation which
      * ensures that the internal mode is properly ended.
      */
     virtual void leaveMoveResize();
     virtual void positionGeometryTip();
     void performMoveResize();
     /**
      * Called from performMoveResize() after actually performing the change of geometry.
      * Implementing subclasses can perform windowing system specific handling here.
      *
      * Default implementation does nothing.
      */
     virtual void doPerformMoveResize();
     /*
      * Checks if the mouse cursor is near the edge of the screen and if so
      * activates quick tiling or maximization
      */
     void checkQuickTilingMaximizationZones(int xroot, int yroot);
     /**
      * Whether a sync request is still pending.
      * Default implementation returns @c false.
      */
     virtual bool isWaitingForMoveResizeSync() const;
     /**
      * Called during handling a resize. Implementing subclasses can use this
      * method to perform windowing system specific syncing.
      *
      * Default implementation does nothing.
      */
     virtual void doResizeSync();
     void handleMoveResize(int x, int y, int x_root, int y_root);
     void handleMoveResize(const QPoint &local, const QPoint &global);
     void dontMoveResize();
 
     virtual QSize resizeIncrements() const;
 
     /**
      * Returns the position depending on the Decoration's section under mouse.
      * If no decoration it returns PositionCenter.
      */
     Position mousePosition() const;
 
     static bool haveResizeEffect() {
         return s_haveResizeEffect;
     }
     static void updateHaveResizeEffect();
     static void resetHaveResizeEffect() {
         s_haveResizeEffect = false;
     }
 
     void setDecoration(KDecoration2::Decoration *decoration) {
         m_decoration.decoration = decoration;
     }
     virtual void destroyDecoration();
     void startDecorationDoubleClickTimer();
     void invalidateDecorationDoubleClickTimer();
 
     void setDesktopFileName(QByteArray name);
     QString iconFromDesktopFile() const;
 
     void updateApplicationMenuServiceName(const QString &serviceName);
     void updateApplicationMenuObjectPath(const QString &objectPath);
 
     void setUnresponsive(bool unresponsive);
 
     virtual void setShortcutInternal();
     QString shortcutCaptionSuffix() const;
     virtual void updateCaption() = 0;
 
     /**
      * Looks for another AbstractClient with same captionNormal and captionSuffix.
      * If no such AbstractClient exists @c nullptr is returned.
      */
     AbstractClient *findClientWithSameCaption() const;
 
     void finishWindowRules();
     void discardTemporaryRules();
 
     bool tabTo(AbstractClient *other, bool behind, bool activate);
 
 private:
     void handlePaletteChange();
     QSharedPointer<TabBox::TabBoxClientImpl> m_tabBoxClient;
     bool m_firstInTabBox = false;
     bool m_skipTaskbar = false;
     /**
      * Unaffected by KWin
      */
     bool m_originalSkipTaskbar = false;
     bool m_skipPager = false;
     bool m_skipSwitcher = false;
     QIcon m_icon;
     bool m_active = false;
     bool m_keepAbove = false;
     bool m_keepBelow = false;
     bool m_demandsAttention = false;
     bool m_minimized = false;
     QTimer *m_autoRaiseTimer = nullptr;
     QVector <VirtualDesktop *> m_desktops;
 
     QString m_colorScheme;
     std::shared_ptr<Decoration::DecorationPalette> m_palette;
     static QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> s_palettes;
     static std::shared_ptr<Decoration::DecorationPalette> s_defaultPalette;
 
     KWayland::Server::PlasmaWindowInterface *m_windowManagementInterface = nullptr;
 
     AbstractClient *m_transientFor = nullptr;
     QList<AbstractClient*> m_transients;
     bool m_modal = false;
     Layer m_layer = UnknownLayer;
 
     // electric border/quick tiling
     QuickTileMode m_electricMode = QuickTileFlag::None;
     bool m_electricMaximizing = false;
     // The quick tile mode of this window.
     int m_quickTileMode = int(QuickTileFlag::None);
     QTimer *m_electricMaximizingDelay = nullptr;
 
     // geometry
     int m_blockGeometryUpdates = 0; // > 0 = New geometry is remembered, but not actually set
     PendingGeometry_t m_pendingGeometryUpdate = PendingGeometryNone;
     friend class GeometryUpdatesBlocker;
     QRect m_visibleRectBeforeGeometryUpdate;
     QRect m_bufferGeometryBeforeUpdateBlocking;
     QRect m_frameGeometryBeforeUpdateBlocking;
     QRect m_virtualKeyboardGeometry;
     QRect m_keyboardGeometryRestore;
     QRect m_maximizeGeometryRestore;
 
     struct {
         bool enabled = false;
         bool unrestricted = false;
         QPoint offset;
         QPoint invertedOffset;
         QRect initialGeometry;
         QRect geometry;
         Position pointer = PositionCenter;
         bool buttonDown = false;
         CursorShape cursor = Qt::ArrowCursor;
         int startScreen = 0;
         QTimer *delayedTimer = nullptr;
     } m_moveResize;
 
     struct {
         KDecoration2::Decoration *decoration = nullptr;
         QPointer<Decoration::DecoratedClientImpl> client;
         QElapsedTimer doubleClickTimer;
     } m_decoration;
     QByteArray m_desktopFileName;
 
     bool m_applicationMenuActive = false;
     QString m_applicationMenuServiceName;
     QString m_applicationMenuObjectPath;
 
     bool m_unresponsive = false;
 
     QKeySequence _shortcut;
 
     WindowRules m_rules;
 
     static bool s_haveResizeEffect;
 };
 
 /**
  * Helper for AbstractClient::blockGeometryUpdates() being called in pairs (true/false)
  */
 class GeometryUpdatesBlocker
 {
 public:
     explicit GeometryUpdatesBlocker(AbstractClient* c)
         : cl(c) {
         cl->blockGeometryUpdates(true);
     }
     ~GeometryUpdatesBlocker() {
         cl->blockGeometryUpdates(false);
     }
 
 private:
     AbstractClient* cl;
 };
 
 inline void AbstractClient::move(const QPoint& p, ForceGeometry_t force)
 {
     move(p.x(), p.y(), force);
 }
 
 inline void AbstractClient::resizeWithChecks(const QSize& s, AbstractClient::ForceGeometry_t force)
 {
     resizeWithChecks(s.width(), s.height(), force);
 }
 
 inline void AbstractClient::setFrameGeometry(const QRect &rect, ForceGeometry_t force)
 {
     setFrameGeometry(rect.x(), rect.y(), rect.width(), rect.height(), force);
 }
 
 inline const QList<AbstractClient*>& AbstractClient::transients() const
 {
     return m_transients;
 }
 
 inline bool AbstractClient::areGeometryUpdatesBlocked() const
 {
     return m_blockGeometryUpdates != 0;
 }
 
 inline void AbstractClient::blockGeometryUpdates()
 {
     m_blockGeometryUpdates++;
 }
 
 inline void AbstractClient::unblockGeometryUpdates()
 {
     m_blockGeometryUpdates--;
 }
 
 inline AbstractClient::PendingGeometry_t AbstractClient::pendingGeometryUpdate() const
 {
     return m_pendingGeometryUpdate;
 }
 
 inline void AbstractClient::setPendingGeometryUpdate(PendingGeometry_t update)
 {
     m_pendingGeometryUpdate = update;
 }
 
 }
 
 Q_DECLARE_METATYPE(KWin::AbstractClient*)
 Q_DECLARE_METATYPE(QList<KWin::AbstractClient*>)
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AbstractClient::SameApplicationChecks)
 
 #endif
diff --git a/autotests/integration/activation_test.cpp b/autotests/integration/activation_test.cpp
index fc9314036..c0898374a 100644
--- a/autotests/integration/activation_test.cpp
+++ b/autotests/integration/activation_test.cpp
@@ -1,585 +1,584 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
+#include "abstract_client.h"
 #include "cursor.h"
 #include "platform.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 
 #include <KWayland/Client/surface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_activation-0");
 
 class ActivationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testSwitchToWindowToLeft();
     void testSwitchToWindowToRight();
     void testSwitchToWindowAbove();
     void testSwitchToWindowBelow();
     void testSwitchToWindowMaximized();
     void testSwitchToWindowFullScreen();
 
 private:
     void stackScreensHorizontally();
     void stackScreensVertically();
 };
 
 void ActivationTest::initTestCase()
 {
     qRegisterMetaType<AbstractClient *>();
-    qRegisterMetaType<XdgShellClient *>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void ActivationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void ActivationTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     stackScreensHorizontally();
 }
 
 void ActivationTest::testSwitchToWindowToLeft()
 {
     // This test verifies that "Switch to Window to the Left" shortcut works.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensHorizontally();
 
     // Create several clients on the left screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
 
     client1->move(QPoint(300, 200));
     client2->move(QPoint(500, 200));
 
     // Create several clients on the right screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(1380, 200));
     client4->move(QPoint(1580, 200));
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client3->isActive());
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client2->isActive());
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client1->isActive());
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::testSwitchToWindowToRight()
 {
     // This test verifies that "Switch to Window to the Right" shortcut works.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensHorizontally();
 
     // Create several clients on the left screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
 
     client1->move(QPoint(300, 200));
     client2->move(QPoint(500, 200));
 
     // Create several clients on the right screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(1380, 200));
     client4->move(QPoint(1580, 200));
 
     // Switch to window to the right.
     workspace()->switchWindow(Workspace::DirectionEast);
     QVERIFY(client1->isActive());
 
     // Switch to window to the right.
     workspace()->switchWindow(Workspace::DirectionEast);
     QVERIFY(client2->isActive());
 
     // Switch to window to the right.
     workspace()->switchWindow(Workspace::DirectionEast);
     QVERIFY(client3->isActive());
 
     // Switch to window to the right.
     workspace()->switchWindow(Workspace::DirectionEast);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::testSwitchToWindowAbove()
 {
     // This test verifies that "Switch to Window Above" shortcut works.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensVertically();
 
     // Create several clients on the top screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
 
     client1->move(QPoint(200, 300));
     client2->move(QPoint(200, 500));
 
     // Create several clients on the bottom screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(200, 1224));
     client4->move(QPoint(200, 1424));
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client3->isActive());
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client2->isActive());
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client1->isActive());
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::testSwitchToWindowBelow()
 {
     // This test verifies that "Switch to Window Bottom" shortcut works.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensVertically();
 
     // Create several clients on the top screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
 
     client1->move(QPoint(200, 300));
     client2->move(QPoint(200, 500));
 
     // Create several clients on the bottom screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(200, 1224));
     client4->move(QPoint(200, 1424));
 
     // Switch to window below.
     workspace()->switchWindow(Workspace::DirectionSouth);
     QVERIFY(client1->isActive());
 
     // Switch to window below.
     workspace()->switchWindow(Workspace::DirectionSouth);
     QVERIFY(client2->isActive());
 
     // Switch to window below.
     workspace()->switchWindow(Workspace::DirectionSouth);
     QVERIFY(client3->isActive());
 
     // Switch to window below.
     workspace()->switchWindow(Workspace::DirectionSouth);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::testSwitchToWindowMaximized()
 {
     // This test verifies that we switch to the top-most maximized client, i.e.
     // the one that user sees at the moment. See bug 411356.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensHorizontally();
 
     // Create several maximized clients on the left screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
     QSignalSpy configureRequestedSpy1(shellSurface1.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy1.wait());
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy1.wait());
-    QSignalSpy frameGeometryChangedSpy1(client1, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy1(client1, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy1.isValid());
     shellSurface1->ackConfigure(configureRequestedSpy1.last().at(2).value<quint32>());
     Test::render(surface1.data(), configureRequestedSpy1.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy1.wait());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
     QSignalSpy configureRequestedSpy2(shellSurface2.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy2.wait());
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy2.wait());
-    QSignalSpy frameGeometryChangedSpy2(client2, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy2(client2, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy2.isValid());
     shellSurface2->ackConfigure(configureRequestedSpy2.last().at(2).value<quint32>());
     Test::render(surface2.data(), configureRequestedSpy2.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy2.wait());
 
     const QList<Toplevel *> stackingOrder = workspace()->stackingOrder();
     QVERIFY(stackingOrder.indexOf(client1) < stackingOrder.indexOf(client2));
     QCOMPARE(client1->maximizeMode(), MaximizeFull);
     QCOMPARE(client2->maximizeMode(), MaximizeFull);
 
     // Create several clients on the right screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(1380, 200));
     client4->move(QPoint(1580, 200));
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client3->isActive());
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client2->isActive());
 
     // Switch to window to the left.
     workspace()->switchWindow(Workspace::DirectionWest);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::testSwitchToWindowFullScreen()
 {
     // This test verifies that we switch to the top-most fullscreen client, i.e.
     // the one that user sees at the moment. See bug 411356.
 
     using namespace KWayland::Client;
 
     // Prepare the test environment.
     stackScreensVertically();
 
     // Create several maximized clients on the top screen.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
     QSignalSpy configureRequestedSpy1(shellSurface1.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy1.wait());
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy1.wait());
-    QSignalSpy frameGeometryChangedSpy1(client1, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy1(client1, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy1.isValid());
     shellSurface1->ackConfigure(configureRequestedSpy1.last().at(2).value<quint32>());
     Test::render(surface1.data(), configureRequestedSpy1.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy1.wait());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
     QSignalSpy configureRequestedSpy2(shellSurface2.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy2.wait());
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy2.wait());
-    QSignalSpy frameGeometryChangedSpy2(client2, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy2(client2, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy2.isValid());
     shellSurface2->ackConfigure(configureRequestedSpy2.last().at(2).value<quint32>());
     Test::render(surface2.data(), configureRequestedSpy2.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy2.wait());
 
     const QList<Toplevel *> stackingOrder = workspace()->stackingOrder();
     QVERIFY(stackingOrder.indexOf(client1) < stackingOrder.indexOf(client2));
     QVERIFY(client1->isFullScreen());
     QVERIFY(client2->isFullScreen());
 
     // Create several clients on the bottom screen.
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client3);
     QVERIFY(client3->isActive());
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
-    XdgShellClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client4);
     QVERIFY(client4->isActive());
 
     client3->move(QPoint(200, 1224));
     client4->move(QPoint(200, 1424));
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client3->isActive());
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client2->isActive());
 
     // Switch to window above.
     workspace()->switchWindow(Workspace::DirectionNorth);
     QVERIFY(client4->isActive());
 
     // Destroy all clients.
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface4.reset();
     QVERIFY(Test::waitForWindowDestroyed(client4));
 }
 
 void ActivationTest::stackScreensHorizontally()
 {
     // Process pending wl_output bind requests before destroying all outputs.
     QTest::qWait(1);
 
     const QVector<QRect> screenGeometries {
         QRect(0, 0, 1280, 1024),
         QRect(1280, 0, 1280, 1024),
     };
 
     const QVector<int> screenScales {
         1,
         1,
     };
 
     QMetaObject::invokeMethod(kwinApp()->platform(),
         "setVirtualOutputs",
         Qt::DirectConnection,
         Q_ARG(int, screenGeometries.count()),
         Q_ARG(QVector<QRect>, screenGeometries),
         Q_ARG(QVector<int>, screenScales)
     );
 }
 
 void ActivationTest::stackScreensVertically()
 {
     // Process pending wl_output bind requests before destroying all outputs.
     QTest::qWait(1);
 
     const QVector<QRect> screenGeometries {
         QRect(0, 0, 1280, 1024),
         QRect(0, 1024, 1280, 1024),
     };
 
     const QVector<int> screenScales {
         1,
         1,
     };
 
     QMetaObject::invokeMethod(kwinApp()->platform(),
         "setVirtualOutputs",
         Qt::DirectConnection,
         Q_ARG(int, screenGeometries.count()),
         Q_ARG(QVector<QRect>, screenGeometries),
         Q_ARG(QVector<int>, screenScales)
     );
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::ActivationTest)
 #include "activation_test.moc"
diff --git a/autotests/integration/activities_test.cpp b/autotests/integration/activities_test.cpp
index 2fa987e87..668ea8d59 100644
--- a/autotests/integration/activities_test.cpp
+++ b/autotests/integration/activities_test.cpp
@@ -1,171 +1,169 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "activities.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "xcbutils.h"
 #include <kwineffects.h>
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_activities-0");
 
 class ActivitiesTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanupTestCase();
     void init();
     void cleanup();
     void testSetOnActivitiesValidates();
 
 private:
 };
 
 void ActivitiesTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setUseKActivities(true);
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void ActivitiesTest::cleanupTestCase()
 {
     // terminate any still running kactivitymanagerd
     QDBusConnection::sessionBus().asyncCall(QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.ActivityManager"),
         QStringLiteral("/ActivityManager"),
         QStringLiteral("org.qtproject.Qt.QCoreApplication"),
         QStringLiteral("quit")));
 }
 
 void ActivitiesTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void ActivitiesTest::cleanup()
 {
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void ActivitiesTest::testSetOnActivitiesValidates()
 {
     // this test creates a Client and sets it on activities which don't exist
     // that should result in the window being on all activities
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry(0, 0, 100, 200);
 
     auto cookie = xcb_create_window_checked(c.data(), 0, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, 0, 0, nullptr);
     QVERIFY(!xcb_request_check(c.data(), cookie));
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
 
     //verify the test machine doesn't have the following activities used
     QVERIFY(!Activities::self()->all().contains(QStringLiteral("foo")));
     QVERIFY(!Activities::self()->all().contains(QStringLiteral("bar")));
 
     //setting the client to an invalid activities should result in the client being on all activities
     client->setOnActivity(QStringLiteral("foo"), true);
     QVERIFY(client->isOnAllActivities());
     QVERIFY(!client->activities().contains(QLatin1String("foo")));
 
     client->setOnActivities(QStringList{QStringLiteral("foo"), QStringLiteral("bar")});
     QVERIFY(client->isOnAllActivities());
     QVERIFY(!client->activities().contains(QLatin1String("foo")));
     QVERIFY(!client->activities().contains(QLatin1String("bar")));
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::ActivitiesTest)
 #include "activities_test.moc"
diff --git a/autotests/integration/buffer_size_change_test.cpp b/autotests/integration/buffer_size_change_test.cpp
index b0c9ffdc2..dd2b2f054 100644
--- a/autotests/integration/buffer_size_change_test.cpp
+++ b/autotests/integration/buffer_size_change_test.cpp
@@ -1,126 +1,126 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 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 "generic_scene_opengl_test.h"
 
+#include "abstract_client.h"
 #include "composite.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_buffer_size_change-0");
 
 class BufferSizeChangeTest : public GenericSceneOpenGLTest
 {
     Q_OBJECT
 public:
     BufferSizeChangeTest() : GenericSceneOpenGLTest(QByteArrayLiteral("O2")) {}
 private Q_SLOTS:
     void init();
     void testShmBufferSizeChange();
     void testShmBufferSizeChangeOnSubSurface();
 };
 
 void BufferSizeChangeTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void BufferSizeChangeTest::testShmBufferSizeChange()
 {
     // This test verifies that an SHM buffer size change is handled correctly
 
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // set buffer size
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // add a first repaint
     QSignalSpy swapSpy(Compositor::self(), &Compositor::bufferSwapCompleted);
     QVERIFY(swapSpy.isValid());
     Compositor::self()->addRepaintFull();
     QVERIFY(swapSpy.wait());
 
     // now change buffer size
     Test::render(surface.data(), QSize(30, 10), Qt::red);
 
-    QSignalSpy damagedSpy(client, &XdgShellClient::damaged);
+    QSignalSpy damagedSpy(client, &AbstractClient::damaged);
     QVERIFY(damagedSpy.isValid());
     QVERIFY(damagedSpy.wait());
     KWin::Compositor::self()->addRepaintFull();
     QVERIFY(swapSpy.wait());
 }
 
 void BufferSizeChangeTest::testShmBufferSizeChangeOnSubSurface()
 {
     using namespace KWayland::Client;
 
     // setup parent surface
     QScopedPointer<Surface> parentSurface(Test::createSurface());
     QVERIFY(!parentSurface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(parentSurface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // setup sub surface
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<SubSurface> subSurface(Test::createSubSurface(surface.data(), parentSurface.data()));
     QVERIFY(!subSurface.isNull());
 
     // set buffer sizes
     Test::render(surface.data(), QSize(30, 10), Qt::red);
-    XdgShellClient *parent = Test::renderAndWaitForShown(parentSurface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *parent = Test::renderAndWaitForShown(parentSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(parent);
 
     // add a first repaint
     QSignalSpy swapSpy(Compositor::self(), &Compositor::bufferSwapCompleted);
     QVERIFY(swapSpy.isValid());
     Compositor::self()->addRepaintFull();
     QVERIFY(swapSpy.wait());
 
     // change buffer size of sub surface
-    QSignalSpy damagedParentSpy(parent, &XdgShellClient::damaged);
+    QSignalSpy damagedParentSpy(parent, &AbstractClient::damaged);
     QVERIFY(damagedParentSpy.isValid());
     Test::render(surface.data(), QSize(20, 10), Qt::red);
     parentSurface->commit(Surface::CommitFlag::None);
 
     QVERIFY(damagedParentSpy.wait());
 
     // add a second repaint
     KWin::Compositor::self()->addRepaintFull();
     QVERIFY(swapSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::BufferSizeChangeTest)
 #include "buffer_size_change_test.moc"
diff --git a/autotests/integration/dbus_interface_test.cpp b/autotests/integration/dbus_interface_test.cpp
index ee09587c6..0d733e1cd 100644
--- a/autotests/integration/dbus_interface_test.cpp
+++ b/autotests/integration/dbus_interface_test.cpp
@@ -1,403 +1,402 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2018 Martin Flöser <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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "atoms.h"
 #include "x11client.h"
 #include "deleted.h"
 #include "platform.h"
 #include "rules.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 
 #include <QDBusArgument>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingReply>
 #include <QUuid>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dbus_interface-0");
 
 const QString s_destination{QStringLiteral("org.kde.KWin")};
 const QString s_path{QStringLiteral("/KWin")};
 const QString s_interface{QStringLiteral("org.kde.KWin")};
 
 class TestDbusInterface : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testGetWindowInfoInvalidUuid();
     void testGetWindowInfoXdgShellClient_data();
     void testGetWindowInfoXdgShellClient();
     void testGetWindowInfoX11Client();
 };
 
 void TestDbusInterface::initTestCase()
 {
     qRegisterMetaType<KWin::Deleted*>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
     VirtualDesktopManager::self()->setCount(4);
 }
 
 void TestDbusInterface::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void TestDbusInterface::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 namespace {
 QDBusPendingCall getWindowInfo(const QUuid &uuid)
 {
     auto msg = QDBusMessage::createMethodCall(s_destination, s_path, s_interface, QStringLiteral("getWindowInfo"));
     msg.setArguments({uuid.toString()});
     return QDBusConnection::sessionBus().asyncCall(msg);
 }
 }
 
 void TestDbusInterface::testGetWindowInfoInvalidUuid()
 {
     QDBusPendingReply<QVariantMap> reply{getWindowInfo(QUuid::createUuid())};
     reply.waitForFinished();
     QVERIFY(reply.isValid());
     QVERIFY(!reply.isError());
     const auto windowData = reply.value();
     QVERIFY(windowData.empty());
 }
 
 void TestDbusInterface::testGetWindowInfoXdgShellClient_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestDbusInterface::testGetWindowInfoXdgShellClient()
 {
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     shellSurface->setAppId(QByteArrayLiteral("org.kde.foo"));
     shellSurface->setTitle(QStringLiteral("Test window"));
 
     // now let's render
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(clientAddedSpy.isEmpty());
     QVERIFY(clientAddedSpy.wait());
-    auto client = clientAddedSpy.first().first().value<XdgShellClient *>();
+    auto client = clientAddedSpy.first().first().value<AbstractClient *>();
     QVERIFY(client);
 
     // let's get the window info
     QDBusPendingReply<QVariantMap> reply{getWindowInfo(client->internalId())};
     reply.waitForFinished();
     QVERIFY(reply.isValid());
     QVERIFY(!reply.isError());
     auto windowData = reply.value();
     QVERIFY(!windowData.isEmpty());
     QCOMPARE(windowData.size(), 24);
     QCOMPARE(windowData.value(QStringLiteral("type")).toInt(), NET::Normal);
     QCOMPARE(windowData.value(QStringLiteral("x")).toInt(), client->x());
     QCOMPARE(windowData.value(QStringLiteral("y")).toInt(), client->y());
     QCOMPARE(windowData.value(QStringLiteral("width")).toInt(), client->width());
     QCOMPARE(windowData.value(QStringLiteral("height")).toInt(), client->height());
     QCOMPARE(windowData.value(QStringLiteral("x11DesktopNumber")).toInt(), 1);
     QCOMPARE(windowData.value(QStringLiteral("minimized")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("shaded")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("fullscreen")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("keepAbove")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("keepBelow")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipTaskbar")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipPager")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipSwitcher")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("maximizeHorizontal")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("maximizeVertical")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("noBorder")).toBool(), true);
     QCOMPARE(windowData.value(QStringLiteral("clientMachine")).toString(), QString());
     QCOMPARE(windowData.value(QStringLiteral("localhost")).toBool(), true);
     QCOMPARE(windowData.value(QStringLiteral("role")).toString(), QString());
     QCOMPARE(windowData.value(QStringLiteral("resourceName")).toString(), QStringLiteral("testDbusInterface"));
     QCOMPARE(windowData.value(QStringLiteral("resourceClass")).toString(), QStringLiteral("org.kde.foo"));
     QCOMPARE(windowData.value(QStringLiteral("desktopFile")).toString(), QStringLiteral("org.kde.foo"));
     QCOMPARE(windowData.value(QStringLiteral("caption")).toString(), QStringLiteral("Test window"));
 
     auto verifyProperty = [client] (const QString &name) {
         QDBusPendingReply<QVariantMap> reply{getWindowInfo(client->internalId())};
         reply.waitForFinished();
         return reply.value().value(name).toBool();
     };
 
     QVERIFY(!client->isMinimized());
     client->setMinimized(true);
     QVERIFY(client->isMinimized());
     QCOMPARE(verifyProperty(QStringLiteral("minimized")), true);
 
     QVERIFY(!client->keepAbove());
     client->setKeepAbove(true);
     QVERIFY(client->keepAbove());
     QCOMPARE(verifyProperty(QStringLiteral("keepAbove")), true);
 
     QVERIFY(!client->keepBelow());
     client->setKeepBelow(true);
     QVERIFY(client->keepBelow());
     QCOMPARE(verifyProperty(QStringLiteral("keepBelow")), true);
 
     QVERIFY(!client->skipTaskbar());
     client->setSkipTaskbar(true);
     QVERIFY(client->skipTaskbar());
     QCOMPARE(verifyProperty(QStringLiteral("skipTaskbar")), true);
 
     QVERIFY(!client->skipPager());
     client->setSkipPager(true);
     QVERIFY(client->skipPager());
     QCOMPARE(verifyProperty(QStringLiteral("skipPager")), true);
 
     QVERIFY(!client->skipSwitcher());
     client->setSkipSwitcher(true);
     QVERIFY(client->skipSwitcher());
     QCOMPARE(verifyProperty(QStringLiteral("skipSwitcher")), true);
 
     // not testing shaded as that's X11
     // not testing fullscreen, maximizeHorizontal, maximizeVertical and noBorder as those require window geometry changes
 
     QCOMPARE(client->desktop(), 1);
     workspace()->sendClientToDesktop(client, 2, false);
     QCOMPARE(client->desktop(), 2);
     reply = getWindowInfo(client->internalId());
     reply.waitForFinished();
     QCOMPARE(reply.value().value(QStringLiteral("x11DesktopNumber")).toInt(), 2);
 
     client->move(10, 20);
     reply = getWindowInfo(client->internalId());
     reply.waitForFinished();
     QCOMPARE(reply.value().value(QStringLiteral("x")).toInt(), client->x());
     QCOMPARE(reply.value().value(QStringLiteral("y")).toInt(), client->y());
     // not testing width, height as that would require window geometry change
 
     // finally close window
     const auto id = client->internalId();
-    QSignalSpy windowClosedSpy(client, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(client, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
     QCOMPARE(windowClosedSpy.count(), 1);
 
     reply = getWindowInfo(id);
     reply.waitForFinished();
     QVERIFY(reply.value().empty());
 }
 
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void TestDbusInterface::testGetWindowInfoX11Client()
 {
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 600, 400);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_icccm_set_wm_class(c.data(), w, 7, "foo\0bar");
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::Properties(), NET::Properties2());
     winInfo.setName("Some caption");
     winInfo.setDesktopFileName("org.kde.foo");
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QCOMPARE(client->clientSize(), windowGeometry.size());
 
     // let's get the window info
     QDBusPendingReply<QVariantMap> reply{getWindowInfo(client->internalId())};
     reply.waitForFinished();
     QVERIFY(reply.isValid());
     QVERIFY(!reply.isError());
     auto windowData = reply.value();
     QVERIFY(!windowData.isEmpty());
     QCOMPARE(windowData.size(), 24);
     QCOMPARE(windowData.value(QStringLiteral("type")).toInt(), NET::Normal);
     QCOMPARE(windowData.value(QStringLiteral("x")).toInt(), client->x());
     QCOMPARE(windowData.value(QStringLiteral("y")).toInt(), client->y());
     QCOMPARE(windowData.value(QStringLiteral("width")).toInt(), client->width());
     QCOMPARE(windowData.value(QStringLiteral("height")).toInt(), client->height());
     QCOMPARE(windowData.value(QStringLiteral("x11DesktopNumber")).toInt(), 1);
     QCOMPARE(windowData.value(QStringLiteral("minimized")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("shaded")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("fullscreen")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("keepAbove")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("keepBelow")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipTaskbar")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipPager")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("skipSwitcher")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("maximizeHorizontal")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("maximizeVertical")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("noBorder")).toBool(), false);
     QCOMPARE(windowData.value(QStringLiteral("role")).toString(), QString());
     QCOMPARE(windowData.value(QStringLiteral("resourceName")).toString(), QStringLiteral("foo"));
     QCOMPARE(windowData.value(QStringLiteral("resourceClass")).toString(), QStringLiteral("bar"));
     QCOMPARE(windowData.value(QStringLiteral("desktopFile")).toString(), QStringLiteral("org.kde.foo"));
     QCOMPARE(windowData.value(QStringLiteral("caption")).toString(), QStringLiteral("Some caption"));
     // not testing clientmachine as that is system dependent
     // due to that also not testing localhost
 
     auto verifyProperty = [client] (const QString &name) {
         QDBusPendingReply<QVariantMap> reply{getWindowInfo(client->internalId())};
         reply.waitForFinished();
         return reply.value().value(name).toBool();
     };
 
     QVERIFY(!client->isMinimized());
     client->setMinimized(true);
     QVERIFY(client->isMinimized());
     QCOMPARE(verifyProperty(QStringLiteral("minimized")), true);
 
     QVERIFY(!client->keepAbove());
     client->setKeepAbove(true);
     QVERIFY(client->keepAbove());
     QCOMPARE(verifyProperty(QStringLiteral("keepAbove")), true);
 
     QVERIFY(!client->keepBelow());
     client->setKeepBelow(true);
     QVERIFY(client->keepBelow());
     QCOMPARE(verifyProperty(QStringLiteral("keepBelow")), true);
 
     QVERIFY(!client->skipTaskbar());
     client->setSkipTaskbar(true);
     QVERIFY(client->skipTaskbar());
     QCOMPARE(verifyProperty(QStringLiteral("skipTaskbar")), true);
 
     QVERIFY(!client->skipPager());
     client->setSkipPager(true);
     QVERIFY(client->skipPager());
     QCOMPARE(verifyProperty(QStringLiteral("skipPager")), true);
 
     QVERIFY(!client->skipSwitcher());
     client->setSkipSwitcher(true);
     QVERIFY(client->skipSwitcher());
     QCOMPARE(verifyProperty(QStringLiteral("skipSwitcher")), true);
 
     QVERIFY(!client->isShade());
     client->setShade(ShadeNormal);
     QVERIFY(client->isShade());
     QCOMPARE(verifyProperty(QStringLiteral("shaded")), true);
     client->setShade(ShadeNone);
     QVERIFY(!client->isShade());
 
     QVERIFY(!client->noBorder());
     client->setNoBorder(true);
     QVERIFY(client->noBorder());
     QCOMPARE(verifyProperty(QStringLiteral("noBorder")), true);
     client->setNoBorder(false);
     QVERIFY(!client->noBorder());
 
     QVERIFY(!client->isFullScreen());
     client->setFullScreen(true);
     QVERIFY(client->isFullScreen());
     QVERIFY(client->clientSize() != windowGeometry.size());
     QCOMPARE(verifyProperty(QStringLiteral("fullscreen")), true);
     reply = getWindowInfo(client->internalId());
     reply.waitForFinished();
     QCOMPARE(reply.value().value(QStringLiteral("width")).toInt(), client->width());
     QCOMPARE(reply.value().value(QStringLiteral("height")).toInt(), client->height());
     client->setFullScreen(false);
     QVERIFY(!client->isFullScreen());
 
     // maximize
     client->setMaximize(true, false);
     QCOMPARE(verifyProperty(QStringLiteral("maximizeVertical")), true);
     QCOMPARE(verifyProperty(QStringLiteral("maximizeHorizontal")), false);
     client->setMaximize(false, true);
     QCOMPARE(verifyProperty(QStringLiteral("maximizeVertical")), false);
     QCOMPARE(verifyProperty(QStringLiteral("maximizeHorizontal")), true);
 
     const auto id = client->internalId();
     // destroy the window
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 
     reply = getWindowInfo(id);
     reply.waitForFinished();
     QVERIFY(reply.value().empty());
 }
 
 WAYLANDTEST_MAIN(TestDbusInterface)
 #include "dbus_interface_test.moc"
diff --git a/autotests/integration/debug_console_test.cpp b/autotests/integration/debug_console_test.cpp
index 292140000..4edd330ab 100644
--- a/autotests/integration/debug_console_test.cpp
+++ b/autotests/integration/debug_console_test.cpp
@@ -1,532 +1,531 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "debug_console.h"
 #include "internal_client.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 #include <QPainter>
 #include <QRasterWindow>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_debug_console-0");
 
 class DebugConsoleTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void topLevelTest_data();
     void topLevelTest();
     void testX11Client();
     void testX11Unmanaged();
     void testWaylandClient_data();
     void testWaylandClient();
     void testInternalWindow();
     void testClosingDebugConsole();
 };
 
 void DebugConsoleTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void DebugConsoleTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DebugConsoleTest::topLevelTest_data()
 {
     QTest::addColumn<int>("row");
     QTest::addColumn<int>("column");
     QTest::addColumn<bool>("expectedValid");
 
     // this tests various combinations of row/column on the top level whether they are valid
     // valid are rows 0-4 with column 0, everything else is invalid
     QTest::newRow("0/0") << 0 << 0 << true;
     QTest::newRow("0/1") << 0 << 1 << false;
     QTest::newRow("0/3") << 0 << 3 << false;
     QTest::newRow("1/0") << 1 << 0 << true;
     QTest::newRow("1/1") << 1 << 1 << false;
     QTest::newRow("1/3") << 1 << 3 << false;
     QTest::newRow("2/0") << 2 << 0 << true;
     QTest::newRow("3/0") << 3 << 0 << true;
     QTest::newRow("4/0") << 4 << 0 << false;
     QTest::newRow("100/0") << 4 << 0 << false;
 }
 
 void DebugConsoleTest::topLevelTest()
 {
     DebugConsoleModel model;
     QCOMPARE(model.rowCount(QModelIndex()), 4);
     QCOMPARE(model.columnCount(QModelIndex()), 2);
     QFETCH(int, row);
     QFETCH(int, column);
     const QModelIndex index = model.index(row, column, QModelIndex());
     QTEST(index.isValid(), "expectedValid");
     if (index.isValid()) {
         QVERIFY(!model.parent(index).isValid());
         QVERIFY(model.data(index, Qt::DisplayRole).isValid());
         QCOMPARE(model.data(index, Qt::DisplayRole).userType(), int(QMetaType::QString));
         for (int i = Qt::DecorationRole; i <= Qt::UserRole; i++) {
             QVERIFY(!model.data(index, i).isValid());
         }
     }
 }
 
 void DebugConsoleTest::testX11Client()
 {
     DebugConsoleModel model;
     QModelIndex x11TopLevelIndex = model.index(0, 0, QModelIndex());
     QVERIFY(x11TopLevelIndex.isValid());
     // we don't have any windows yet
     QCOMPARE(model.rowCount(x11TopLevelIndex), 0);
     QVERIFY(!model.hasChildren(x11TopLevelIndex));
     // child index must be invalid
     QVERIFY(!model.index(0, 0, x11TopLevelIndex).isValid());
     QVERIFY(!model.index(0, 1, x11TopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, x11TopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, x11TopLevelIndex).isValid());
 
     // start glxgears, to get a window, which should be added to the model
     QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
     QVERIFY(rowsInsertedSpy.isValid());
 
     QProcess glxgears;
     glxgears.start(QStringLiteral("glxgears"));
     QVERIFY(glxgears.waitForStarted());
 
     QVERIFY(rowsInsertedSpy.wait());
     QCOMPARE(rowsInsertedSpy.count(), 1);
     QVERIFY(model.hasChildren(x11TopLevelIndex));
     QCOMPARE(model.rowCount(x11TopLevelIndex), 1);
     QCOMPARE(rowsInsertedSpy.first().at(0).value<QModelIndex>(), x11TopLevelIndex);
     QCOMPARE(rowsInsertedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsInsertedSpy.first().at(2).value<int>(), 0);
 
     QModelIndex clientIndex = model.index(0, 0, x11TopLevelIndex);
     QVERIFY(clientIndex.isValid());
     QCOMPARE(model.parent(clientIndex), x11TopLevelIndex);
     QVERIFY(model.hasChildren(clientIndex));
     QVERIFY(model.rowCount(clientIndex) != 0);
     QCOMPARE(model.columnCount(clientIndex), 2);
     // other indexes are still invalid
     QVERIFY(!model.index(0, 1, x11TopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, x11TopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, x11TopLevelIndex).isValid());
 
     // the clientIndex has children and those are properties
     for (int i = 0; i < model.rowCount(clientIndex); i++) {
         const QModelIndex propNameIndex = model.index(i, 0, clientIndex);
         QVERIFY(propNameIndex.isValid());
         QCOMPARE(model.parent(propNameIndex), clientIndex);
         QVERIFY(!model.hasChildren(propNameIndex));
         QVERIFY(!model.index(0, 0, propNameIndex).isValid());
         QVERIFY(model.data(propNameIndex, Qt::DisplayRole).isValid());
         QCOMPARE(model.data(propNameIndex, Qt::DisplayRole).userType(), int(QMetaType::QString));
 
         // and the value
         const QModelIndex propValueIndex = model.index(i, 1, clientIndex);
         QVERIFY(propValueIndex.isValid());
         QCOMPARE(model.parent(propValueIndex), clientIndex);
         QVERIFY(!model.index(0, 0, propValueIndex).isValid());
         QVERIFY(!model.hasChildren(propValueIndex));
         // TODO: how to test whether the values actually work?
 
         // and on third column we should not get an index any more
         QVERIFY(!model.index(i, 2, clientIndex).isValid());
     }
     // row after count should be invalid
     QVERIFY(!model.index(model.rowCount(clientIndex), 0, clientIndex).isValid());
 
     // creating a second model should be initialized directly with the X11 child
     DebugConsoleModel model2;
     QVERIFY(model2.hasChildren(model2.index(0, 0, QModelIndex())));
 
     // now close the window again, it should be removed from the model
     QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
     QVERIFY(rowsRemovedSpy.isValid());
 
     glxgears.terminate();
     QVERIFY(glxgears.waitForFinished());
 
     QVERIFY(rowsRemovedSpy.wait());
     QCOMPARE(rowsRemovedSpy.count(), 1);
     QCOMPARE(rowsRemovedSpy.first().first().value<QModelIndex>(), x11TopLevelIndex);
     QCOMPARE(rowsRemovedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsRemovedSpy.first().at(2).value<int>(), 0);
 
     // the child should be gone again
     QVERIFY(!model.hasChildren(x11TopLevelIndex));
     QVERIFY(!model2.hasChildren(model2.index(0, 0, QModelIndex())));
 }
 
 void DebugConsoleTest::testX11Unmanaged()
 {
     DebugConsoleModel model;
     QModelIndex unmanagedTopLevelIndex = model.index(1, 0, QModelIndex());
     QVERIFY(unmanagedTopLevelIndex.isValid());
     // we don't have any windows yet
     QCOMPARE(model.rowCount(unmanagedTopLevelIndex), 0);
     QVERIFY(!model.hasChildren(unmanagedTopLevelIndex));
     // child index must be invalid
     QVERIFY(!model.index(0, 0, unmanagedTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 1, unmanagedTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, unmanagedTopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, unmanagedTopLevelIndex).isValid());
 
     // we need to create an unmanaged window
     QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
     QVERIFY(rowsInsertedSpy.isValid());
 
     // let's create an override redirect window
     const uint32_t values[] = {true};
     Xcb::Window window(QRect(0, 0, 10, 10), XCB_CW_OVERRIDE_REDIRECT, values);
     window.map();
 
     QVERIFY(rowsInsertedSpy.wait());
     QCOMPARE(rowsInsertedSpy.count(), 1);
     QVERIFY(model.hasChildren(unmanagedTopLevelIndex));
     QCOMPARE(model.rowCount(unmanagedTopLevelIndex), 1);
     QCOMPARE(rowsInsertedSpy.first().at(0).value<QModelIndex>(), unmanagedTopLevelIndex);
     QCOMPARE(rowsInsertedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsInsertedSpy.first().at(2).value<int>(), 0);
 
     QModelIndex clientIndex = model.index(0, 0, unmanagedTopLevelIndex);
     QVERIFY(clientIndex.isValid());
     QCOMPARE(model.parent(clientIndex), unmanagedTopLevelIndex);
     QVERIFY(model.hasChildren(clientIndex));
     QVERIFY(model.rowCount(clientIndex) != 0);
     QCOMPARE(model.columnCount(clientIndex), 2);
     // other indexes are still invalid
     QVERIFY(!model.index(0, 1, unmanagedTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, unmanagedTopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, unmanagedTopLevelIndex).isValid());
 
     QCOMPARE(model.data(clientIndex, Qt::DisplayRole).toString(), QString::number(window));
 
     // the clientIndex has children and those are properties
     for (int i = 0; i < model.rowCount(clientIndex); i++) {
         const QModelIndex propNameIndex = model.index(i, 0, clientIndex);
         QVERIFY(propNameIndex.isValid());
         QCOMPARE(model.parent(propNameIndex), clientIndex);
         QVERIFY(!model.hasChildren(propNameIndex));
         QVERIFY(!model.index(0, 0, propNameIndex).isValid());
         QVERIFY(model.data(propNameIndex, Qt::DisplayRole).isValid());
         QCOMPARE(model.data(propNameIndex, Qt::DisplayRole).userType(), int(QMetaType::QString));
 
         // and the value
         const QModelIndex propValueIndex = model.index(i, 1, clientIndex);
         QVERIFY(propValueIndex.isValid());
         QCOMPARE(model.parent(propValueIndex), clientIndex);
         QVERIFY(!model.index(0, 0, propValueIndex).isValid());
         QVERIFY(!model.hasChildren(propValueIndex));
         // TODO: how to test whether the values actually work?
 
         // and on third column we should not get an index any more
         QVERIFY(!model.index(i, 2, clientIndex).isValid());
     }
     // row after count should be invalid
     QVERIFY(!model.index(model.rowCount(clientIndex), 0, clientIndex).isValid());
 
     // creating a second model should be initialized directly with the X11 child
     DebugConsoleModel model2;
     QVERIFY(model2.hasChildren(model2.index(1, 0, QModelIndex())));
 
     // now close the window again, it should be removed from the model
     QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
     QVERIFY(rowsRemovedSpy.isValid());
 
     window.unmap();
 
     QVERIFY(rowsRemovedSpy.wait());
     QCOMPARE(rowsRemovedSpy.count(), 1);
     QCOMPARE(rowsRemovedSpy.first().first().value<QModelIndex>(), unmanagedTopLevelIndex);
     QCOMPARE(rowsRemovedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsRemovedSpy.first().at(2).value<int>(), 0);
 
     // the child should be gone again
     QVERIFY(!model.hasChildren(unmanagedTopLevelIndex));
     QVERIFY(!model2.hasChildren(model2.index(1, 0, QModelIndex())));
 }
 
 void DebugConsoleTest::testWaylandClient_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DebugConsoleTest::testWaylandClient()
 {
     DebugConsoleModel model;
     QModelIndex waylandTopLevelIndex = model.index(2, 0, QModelIndex());
     QVERIFY(waylandTopLevelIndex.isValid());
 
     // we don't have any windows yet
     QCOMPARE(model.rowCount(waylandTopLevelIndex), 0);
     QVERIFY(!model.hasChildren(waylandTopLevelIndex));
     // child index must be invalid
     QVERIFY(!model.index(0, 0, waylandTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 1, waylandTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, waylandTopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, waylandTopLevelIndex).isValid());
 
     // we need to create a wayland window
     QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
     QVERIFY(rowsInsertedSpy.isValid());
 
     // create our connection
     QVERIFY(Test::setupWaylandConnection());
 
     // create the Surface and ShellSurface
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(surface->isValid());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(!shellSurface.isNull());
     Test::render(surface.data(), QSize(10, 10), Qt::red);
 
     // now we have the window, it should be added to our model
     QVERIFY(rowsInsertedSpy.wait());
     QCOMPARE(rowsInsertedSpy.count(), 1);
 
     QVERIFY(model.hasChildren(waylandTopLevelIndex));
     QCOMPARE(model.rowCount(waylandTopLevelIndex), 1);
     QCOMPARE(rowsInsertedSpy.first().at(0).value<QModelIndex>(), waylandTopLevelIndex);
     QCOMPARE(rowsInsertedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsInsertedSpy.first().at(2).value<int>(), 0);
 
     QModelIndex clientIndex = model.index(0, 0, waylandTopLevelIndex);
     QVERIFY(clientIndex.isValid());
     QCOMPARE(model.parent(clientIndex), waylandTopLevelIndex);
     QVERIFY(model.hasChildren(clientIndex));
     QVERIFY(model.rowCount(clientIndex) != 0);
     QCOMPARE(model.columnCount(clientIndex), 2);
     // other indexes are still invalid
     QVERIFY(!model.index(0, 1, waylandTopLevelIndex).isValid());
     QVERIFY(!model.index(0, 2, waylandTopLevelIndex).isValid());
     QVERIFY(!model.index(1, 0, waylandTopLevelIndex).isValid());
 
     // the clientIndex has children and those are properties
     for (int i = 0; i < model.rowCount(clientIndex); i++) {
         const QModelIndex propNameIndex = model.index(i, 0, clientIndex);
         QVERIFY(propNameIndex.isValid());
         QCOMPARE(model.parent(propNameIndex), clientIndex);
         QVERIFY(!model.hasChildren(propNameIndex));
         QVERIFY(!model.index(0, 0, propNameIndex).isValid());
         QVERIFY(model.data(propNameIndex, Qt::DisplayRole).isValid());
         QCOMPARE(model.data(propNameIndex, Qt::DisplayRole).userType(), int(QMetaType::QString));
 
         // and the value
         const QModelIndex propValueIndex = model.index(i, 1, clientIndex);
         QVERIFY(propValueIndex.isValid());
         QCOMPARE(model.parent(propValueIndex), clientIndex);
         QVERIFY(!model.index(0, 0, propValueIndex).isValid());
         QVERIFY(!model.hasChildren(propValueIndex));
         // TODO: how to test whether the values actually work?
 
         // and on third column we should not get an index any more
         QVERIFY(!model.index(i, 2, clientIndex).isValid());
     }
     // row after count should be invalid
     QVERIFY(!model.index(model.rowCount(clientIndex), 0, clientIndex).isValid());
 
     // creating a second model should be initialized directly with the X11 child
     DebugConsoleModel model2;
     QVERIFY(model2.hasChildren(model2.index(2, 0, QModelIndex())));
 
     // now close the window again, it should be removed from the model
     QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
     QVERIFY(rowsRemovedSpy.isValid());
 
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     shellSurface.reset();
     Test::flushWaylandConnection();
     qDebug() << rowsRemovedSpy.count();
     QEXPECT_FAIL("wlShell", "Deleting a ShellSurface does not result in the server removing the XdgShellClient", Continue);
     QVERIFY(rowsRemovedSpy.wait(500));
     surface.reset();
 
     if (rowsRemovedSpy.isEmpty()) {
         QVERIFY(rowsRemovedSpy.wait());
     }
     QCOMPARE(rowsRemovedSpy.count(), 1);
     QCOMPARE(rowsRemovedSpy.first().first().value<QModelIndex>(), waylandTopLevelIndex);
     QCOMPARE(rowsRemovedSpy.first().at(1).value<int>(), 0);
     QCOMPARE(rowsRemovedSpy.first().at(2).value<int>(), 0);
 
     // the child should be gone again
     QVERIFY(!model.hasChildren(waylandTopLevelIndex));
     QVERIFY(!model2.hasChildren(model2.index(2, 0, QModelIndex())));
 }
 
 class HelperWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     HelperWindow() : QRasterWindow(nullptr) {}
     ~HelperWindow() override = default;
 
 Q_SIGNALS:
     void entered();
     void left();
     void mouseMoved(const QPoint &global);
     void mousePressed();
     void mouseReleased();
     void wheel();
     void keyPressed();
     void keyReleased();
 
 protected:
     void paintEvent(QPaintEvent *event) override {
         Q_UNUSED(event)
         QPainter p(this);
         p.fillRect(0, 0, width(), height(), Qt::red);
     }
 };
 
 void DebugConsoleTest::testInternalWindow()
 {
     DebugConsoleModel model;
     QModelIndex internalTopLevelIndex = model.index(3, 0, QModelIndex());
     QVERIFY(internalTopLevelIndex.isValid());
 
     // there might already be some internal windows, so we cannot reliable test whether there are children
     // given that we just test whether adding a window works.
 
     QSignalSpy rowsInsertedSpy(&model, &QAbstractItemModel::rowsInserted);
     QVERIFY(rowsInsertedSpy.isValid());
 
     QScopedPointer<HelperWindow> w(new HelperWindow);
     w->setGeometry(0, 0, 100, 100);
     w->show();
 
     QTRY_COMPARE(rowsInsertedSpy.count(), 1);
     QCOMPARE(rowsInsertedSpy.first().first().value<QModelIndex>(), internalTopLevelIndex);
 
     QModelIndex clientIndex = model.index(rowsInsertedSpy.first().last().toInt(), 0, internalTopLevelIndex);
     QVERIFY(clientIndex.isValid());
     QCOMPARE(model.parent(clientIndex), internalTopLevelIndex);
     QVERIFY(model.hasChildren(clientIndex));
     QVERIFY(model.rowCount(clientIndex) != 0);
     QCOMPARE(model.columnCount(clientIndex), 2);
     // other indexes are still invalid
     QVERIFY(!model.index(rowsInsertedSpy.first().last().toInt(), 1, internalTopLevelIndex).isValid());
     QVERIFY(!model.index(rowsInsertedSpy.first().last().toInt(), 2, internalTopLevelIndex).isValid());
     QVERIFY(!model.index(rowsInsertedSpy.first().last().toInt() + 1, 0, internalTopLevelIndex).isValid());
 
     // the wayland shell client top level should not have gained this window
     QVERIFY(!model.hasChildren(model.index(2, 0, QModelIndex())));
 
     // the clientIndex has children and those are properties
     for (int i = 0; i < model.rowCount(clientIndex); i++) {
         const QModelIndex propNameIndex = model.index(i, 0, clientIndex);
         QVERIFY(propNameIndex.isValid());
         QCOMPARE(model.parent(propNameIndex), clientIndex);
         QVERIFY(!model.hasChildren(propNameIndex));
         QVERIFY(!model.index(0, 0, propNameIndex).isValid());
         QVERIFY(model.data(propNameIndex, Qt::DisplayRole).isValid());
         QCOMPARE(model.data(propNameIndex, Qt::DisplayRole).userType(), int(QMetaType::QString));
 
         // and the value
         const QModelIndex propValueIndex = model.index(i, 1, clientIndex);
         QVERIFY(propValueIndex.isValid());
         QCOMPARE(model.parent(propValueIndex), clientIndex);
         QVERIFY(!model.index(0, 0, propValueIndex).isValid());
         QVERIFY(!model.hasChildren(propValueIndex));
         // TODO: how to test whether the values actually work?
 
         // and on third column we should not get an index any more
         QVERIFY(!model.index(i, 2, clientIndex).isValid());
     }
     // row after count should be invalid
     QVERIFY(!model.index(model.rowCount(clientIndex), 0, clientIndex).isValid());
 
     // now close the window again, it should be removed from the model
     QSignalSpy rowsRemovedSpy(&model, &QAbstractItemModel::rowsRemoved);
     QVERIFY(rowsRemovedSpy.isValid());
 
     w->hide();
     w.reset();
 
     QTRY_COMPARE(rowsRemovedSpy.count(), 1);
     QCOMPARE(rowsRemovedSpy.first().first().value<QModelIndex>(), internalTopLevelIndex);
 }
 
 void DebugConsoleTest::testClosingDebugConsole()
 {
     // this test verifies that the DebugConsole gets destroyed when closing the window
     // BUG: 369858
 
     DebugConsole *console = new DebugConsole;
     QSignalSpy destroyedSpy(console, &QObject::destroyed);
     QVERIFY(destroyedSpy.isValid());
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     console->show();
     QCOMPARE(console->windowHandle()->isVisible(), true);
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     InternalClient *c = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(c->isInternal());
     QCOMPARE(c->internalWindow(), console->windowHandle());
     QVERIFY(c->isDecorated());
     QCOMPARE(c->isMinimizable(), false);
     c->closeWindow();
     QVERIFY(destroyedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DebugConsoleTest)
 #include "debug_console_test.moc"
diff --git a/autotests/integration/decoration_input_test.cpp b/autotests/integration/decoration_input_test.cpp
index b7e27b9b3..39ae0d8cb 100644
--- a/autotests/integration/decoration_input_test.cpp
+++ b/autotests/integration/decoration_input_test.cpp
@@ -1,888 +1,886 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "internal_client.h"
 #include "platform.h"
 #include "pointer_input.h"
 #include "touch_input.h"
 #include "screenedge.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 #include <linux/input.h>
 
 Q_DECLARE_METATYPE(Qt::WindowFrameSection)
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_decoration_input-0");
 
 class DecorationInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testAxis_data();
     void testAxis();
     void testDoubleClick_data();
     void testDoubleClick();
     void testDoubleTap_data();
     void testDoubleTap();
     void testHover_data();
     void testHover();
     void testPressToMove_data();
     void testPressToMove();
     void testTapToMove_data();
     void testTapToMove();
     void testResizeOutsideWindow_data();
     void testResizeOutsideWindow();
     void testModifierClickUnrestrictedMove_data();
     void testModifierClickUnrestrictedMove();
     void testModifierScrollOpacity_data();
     void testModifierScrollOpacity();
     void testTouchEvents_data();
     void testTouchEvents();
     void testTooltipDoesntEatKeyEvents_data();
     void testTooltipDoesntEatKeyEvents();
 
 private:
     AbstractClient *showWindow(Test::XdgShellSurfaceType type);
 };
 
 #define MOTION(target) \
     kwinApp()->platform()->pointerMotion(target, timestamp++)
 
 #define PRESS \
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++)
 
 #define RELEASE \
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++)
 
 AbstractClient *DecorationInputTest::showWindow(Test::XdgShellSurfaceType type)
 {
     using namespace KWayland::Client;
 #define VERIFY(statement) \
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
         return nullptr;
 #define COMPARE(actual, expected) \
     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\
         return nullptr;
 
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     VERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellSurface(type, surface, surface);
     VERIFY(shellSurface);
     auto deco = Test::waylandServerSideDecoration()->create(surface, surface);
     QSignalSpy decoSpy(deco, &ServerSideDecoration::modeChanged);
     VERIFY(decoSpy.isValid());
     VERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     VERIFY(decoSpy.wait());
     COMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
     // let's render
     auto c = Test::renderAndWaitForShown(surface, QSize(500, 50), Qt::blue);
     VERIFY(c);
     COMPARE(workspace()->activeClient(), c);
 
 #undef VERIFY
 #undef COMPARE
 
     return c;
 }
 
 void DecorationInputTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // change some options
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group(QStringLiteral("MouseBindings")).writeEntry("CommandTitlebarWheel", QStringLiteral("above/below"));
     config->group(QStringLiteral("Windows")).writeEntry("TitlebarDoubleClickCommand", QStringLiteral("OnAllDesktops"));
     config->group(QStringLiteral("Desktops")).writeEntry("Number", 2);
     config->sync();
 
     kwinApp()->setConfig(config);
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void DecorationInputTest::init()
 {
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::Decoration));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void DecorationInputTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DecorationInputTest::testAxis_data()
 {
     QTest::addColumn<QPoint>("decoPoint");
     QTest::addColumn<Qt::WindowFrameSection>("expectedSection");
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("topLeft|xdgv6") << QPoint(0, 0) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("top|xdgv6") << QPoint(250, 0) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topRight|xdgv6") << QPoint(499, 0) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topLeft|xdgWmBase") << QPoint(0, 0) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("top|xdgWmBase") << QPoint(250, 0) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("topRight|xdgWmBase") << QPoint(499, 0) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DecorationInputTest::testAxis()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     QCOMPARE(c->titlebarPosition(), AbstractClient::PositionTop);
     QVERIFY(!c->keepAbove());
     QVERIFY(!c->keepBelow());
 
     quint32 timestamp = 1;
     MOTION(QPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2));
     QVERIFY(!input()->pointer()->decoration().isNull());
     QCOMPARE(input()->pointer()->decoration()->decoration()->sectionUnderMouse(), Qt::TitleBarArea);
 
     // TODO: mouse wheel direction looks wrong to me
     // simulate wheel
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(c->keepBelow());
     QVERIFY(!c->keepAbove());
     kwinApp()->platform()->pointerAxisVertical(-5.0, timestamp++);
     QVERIFY(!c->keepBelow());
     QVERIFY(!c->keepAbove());
     kwinApp()->platform()->pointerAxisVertical(-5.0, timestamp++);
     QVERIFY(!c->keepBelow());
     QVERIFY(c->keepAbove());
 
     // test top most deco pixel, BUG: 362860
     c->move(0, 0);
     QFETCH(QPoint, decoPoint);
     MOTION(decoPoint);
     QVERIFY(!input()->pointer()->decoration().isNull());
     QCOMPARE(input()->pointer()->decoration()->client(), c);
     QTEST(input()->pointer()->decoration()->decoration()->sectionUnderMouse(), "expectedSection");
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(!c->keepBelow());
     QVERIFY(!c->keepAbove());
 }
 
 void DecorationInputTest::testDoubleClick_data()
 {
     QTest::addColumn<QPoint>("decoPoint");
     QTest::addColumn<Qt::WindowFrameSection>("expectedSection");
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("topLeft|xdgv6") << QPoint(0, 0) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("top|xdgv6") << QPoint(250, 0) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topRight|xdgv6") << QPoint(499, 0) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topLeft|xdgWmBase") << QPoint(0, 0) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("top|xdgWmBase") << QPoint(250, 0) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("topRight|xdgWmBase") << QPoint(499, 0) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void KWin::DecorationInputTest::testDoubleClick()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     QVERIFY(!c->isOnAllDesktops());
     quint32 timestamp = 1;
     MOTION(QPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2));
 
     // double click
     PRESS;
     RELEASE;
     PRESS;
     RELEASE;
     QVERIFY(c->isOnAllDesktops());
     // double click again
     PRESS;
     RELEASE;
     QVERIFY(c->isOnAllDesktops());
     PRESS;
     RELEASE;
     QVERIFY(!c->isOnAllDesktops());
 
     // test top most deco pixel, BUG: 362860
     c->move(0, 0);
     QFETCH(QPoint, decoPoint);
     MOTION(decoPoint);
     QVERIFY(!input()->pointer()->decoration().isNull());
     QCOMPARE(input()->pointer()->decoration()->client(), c);
     QTEST(input()->pointer()->decoration()->decoration()->sectionUnderMouse(), "expectedSection");
     // double click
     PRESS;
     RELEASE;
     QVERIFY(!c->isOnAllDesktops());
     PRESS;
     RELEASE;
     QVERIFY(c->isOnAllDesktops());
 }
 
 void DecorationInputTest::testDoubleTap_data()
 {
     QTest::addColumn<QPoint>("decoPoint");
     QTest::addColumn<Qt::WindowFrameSection>("expectedSection");
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("topLeft|xdgv6") << QPoint(10, 10) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("top|xdgv6") << QPoint(260, 10) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topRight|xdgv6") << QPoint(509, 10) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("topLeft|xdgWmBase") << QPoint(10, 10) << Qt::TopLeftSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("top|xdgWmBase") << QPoint(260, 10) << Qt::TopSection << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("topRight|xdgWmBase") << QPoint(509, 10) << Qt::TopRightSection << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void KWin::DecorationInputTest::testDoubleTap()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     QVERIFY(!c->isOnAllDesktops());
     quint32 timestamp = 1;
     const QPoint tapPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2);
 
     // double tap
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(c->isOnAllDesktops());
     // double tap again
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(c->isOnAllDesktops());
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(!c->isOnAllDesktops());
 
     // test top most deco pixel, BUG: 362860
     //
     // Not directly at (0, 0), otherwise ScreenEdgeInputFilter catches
     // event before DecorationEventFilter.
     c->move(10, 10);
     QFETCH(QPoint, decoPoint);
     // double click
     kwinApp()->platform()->touchDown(0, decoPoint, timestamp++);
     QVERIFY(!input()->touch()->decoration().isNull());
     QCOMPARE(input()->touch()->decoration()->client(), c);
     QTEST(input()->touch()->decoration()->decoration()->sectionUnderMouse(), "expectedSection");
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(!c->isOnAllDesktops());
     kwinApp()->platform()->touchDown(0, decoPoint, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(c->isOnAllDesktops());
 }
 
 void DecorationInputTest::testHover_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DecorationInputTest::testHover()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
 
     // our left border is moved out of the visible area, so move the window to a better place
     c->move(QPoint(20, 0));
 
     quint32 timestamp = 1;
     MOTION(QPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2));
     QCOMPARE(c->cursor(), CursorShape(Qt::ArrowCursor));
 
     // There is a mismatch of the cursor key positions between windows
     // with and without borders (with borders one can move inside a bit and still
     // be on an edge, without not). We should make this consistent in KWin's core.
     //
     // TODO: Test input position with different border sizes.
     // TODO: We should test with the fake decoration to have a fixed test environment.
     const bool hasBorders = Decoration::DecorationBridge::self()->settings()->borderSize() != KDecoration2::BorderSize::None;
     auto deviation = [hasBorders] {
         return hasBorders ? -1 : 0;
     };
 
     MOTION(QPoint(c->frameGeometry().x(), 0));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeNorthWest));
     MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() / 2, 0));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeNorth));
     MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() - 1, 0));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeNorthEast));
     MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() + deviation(), c->height() / 2));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeEast));
     MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() + deviation(), c->height() - 1));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeSouthEast));
     MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() / 2, c->height() + deviation()));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeSouth));
     MOTION(QPoint(c->frameGeometry().x(), c->height() + deviation()));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeSouthWest));
     MOTION(QPoint(c->frameGeometry().x() - 1, c->height() / 2));
     QCOMPARE(c->cursor(), CursorShape(KWin::ExtendedCursor::SizeWest));
 
     MOTION(c->frameGeometry().center());
     QEXPECT_FAIL("", "Cursor not set back on leave", Continue);
     QCOMPARE(c->cursor(), CursorShape(Qt::ArrowCursor));
 }
 
 void DecorationInputTest::testPressToMove_data()
 {
     QTest::addColumn<QPoint>("offset");
     QTest::addColumn<QPoint>("offset2");
     QTest::addColumn<QPoint>("offset3");
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("To right|xdgv6")  << QPoint(10, 0)  << QPoint(20, 0)  << QPoint(30, 0) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To left|xdgv6")   << QPoint(-10, 0) << QPoint(-20, 0) << QPoint(-30, 0) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To bottom|xdgv6") << QPoint(0, 10)  << QPoint(0, 20)  << QPoint(0, 30) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To top|xdgv6")    << QPoint(0, -10) << QPoint(0, -20) << QPoint(0, -30) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To right|xdgWmBase")  << QPoint(10, 0)  << QPoint(20, 0)  << QPoint(30, 0) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To left|xdgWmBase")   << QPoint(-10, 0) << QPoint(-20, 0) << QPoint(-30, 0) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To bottom|xdgWmBase") << QPoint(0, 10)  << QPoint(0, 20)  << QPoint(0, 30) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To top|xdgWmBase")    << QPoint(0, -10) << QPoint(0, -20) << QPoint(0, -30) << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DecorationInputTest::testPressToMove()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     c->move(screens()->geometry(0).center() - QPoint(c->width()/2, c->height()/2));
     QSignalSpy startMoveResizedSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(startMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(c, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     quint32 timestamp = 1;
     MOTION(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2));
     QCOMPARE(c->cursor(), CursorShape(Qt::ArrowCursor));
 
     PRESS;
     QVERIFY(!c->isMove());
     QFETCH(QPoint, offset);
     MOTION(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2) + offset);
     const QPoint oldPos = c->pos();
     QVERIFY(c->isMove());
     QCOMPARE(startMoveResizedSpy.count(), 1);
 
     RELEASE;
     QTRY_VERIFY(!c->isMove());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QEXPECT_FAIL("", "Just trigger move doesn't move the window", Continue);
     QCOMPARE(c->pos(), oldPos + offset);
 
     // again
     PRESS;
     QVERIFY(!c->isMove());
     QFETCH(QPoint, offset2);
     MOTION(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2) + offset2);
     QVERIFY(c->isMove());
     QCOMPARE(startMoveResizedSpy.count(), 2);
     QFETCH(QPoint, offset3);
     MOTION(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2) + offset3);
 
     RELEASE;
     QTRY_VERIFY(!c->isMove());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 2);
     // TODO: the offset should also be included
     QCOMPARE(c->pos(), oldPos + offset2 + offset3);
 }
 
 void DecorationInputTest::testTapToMove_data()
 {
     QTest::addColumn<QPoint>("offset");
     QTest::addColumn<QPoint>("offset2");
     QTest::addColumn<QPoint>("offset3");
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("To right|xdgv6")  << QPoint(10, 0)  << QPoint(20, 0)  << QPoint(30, 0) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To left|xdgv6")   << QPoint(-10, 0) << QPoint(-20, 0) << QPoint(-30, 0) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To bottom|xdgv6") << QPoint(0, 10)  << QPoint(0, 20)  << QPoint(0, 30) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To top|xdgv6")    << QPoint(0, -10) << QPoint(0, -20) << QPoint(0, -30) << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("To right|xdgWmBase")  << QPoint(10, 0)  << QPoint(20, 0)  << QPoint(30, 0) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To left|xdgWmBase")   << QPoint(-10, 0) << QPoint(-20, 0) << QPoint(-30, 0) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To bottom|xdgWmBase") << QPoint(0, 10)  << QPoint(0, 20)  << QPoint(0, 30) << Test::XdgShellSurfaceType::XdgShellStable;
     QTest::newRow("To top|xdgWmBase")    << QPoint(0, -10) << QPoint(0, -20) << QPoint(0, -30) << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DecorationInputTest::testTapToMove()
 {
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     c->move(screens()->geometry(0).center() - QPoint(c->width()/2, c->height()/2));
     QSignalSpy startMoveResizedSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(startMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(c, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     quint32 timestamp = 1;
     QPoint p = QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2);
 
     kwinApp()->platform()->touchDown(0, p, timestamp++);
     QVERIFY(!c->isMove());
     QFETCH(QPoint, offset);
     QCOMPARE(input()->touch()->decorationPressId(), 0);
     kwinApp()->platform()->touchMotion(0, p + offset, timestamp++);
     const QPoint oldPos = c->pos();
     QVERIFY(c->isMove());
     QCOMPARE(startMoveResizedSpy.count(), 1);
 
     kwinApp()->platform()->touchUp(0, timestamp++);
     QTRY_VERIFY(!c->isMove());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QEXPECT_FAIL("", "Just trigger move doesn't move the window", Continue);
     QCOMPARE(c->pos(), oldPos + offset);
 
     // again
     kwinApp()->platform()->touchDown(1, p + offset, timestamp++);
     QCOMPARE(input()->touch()->decorationPressId(), 1);
     QVERIFY(!c->isMove());
     QFETCH(QPoint, offset2);
     kwinApp()->platform()->touchMotion(1, QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2) + offset2, timestamp++);
     QVERIFY(c->isMove());
     QCOMPARE(startMoveResizedSpy.count(), 2);
     QFETCH(QPoint, offset3);
     kwinApp()->platform()->touchMotion(1, QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2) + offset3, timestamp++);
 
     kwinApp()->platform()->touchUp(1, timestamp++);
     QTRY_VERIFY(!c->isMove());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 2);
     // TODO: the offset should also be included
     QCOMPARE(c->pos(), oldPos + offset2 + offset3);
 }
 
 void DecorationInputTest::testResizeOutsideWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<Qt::Edge>("edge");
     QTest::addColumn<Qt::CursorShape>("expectedCursor");
 
     QTest::newRow("xdgShellV6 - left") << Test::XdgShellSurfaceType::XdgShellV6 << Qt::LeftEdge << Qt::SizeHorCursor;
     QTest::newRow("xdgWmBase - left") << Test::XdgShellSurfaceType::XdgShellStable << Qt::LeftEdge << Qt::SizeHorCursor;
     QTest::newRow("xdgShellV6 - right") << Test::XdgShellSurfaceType::XdgShellV6 << Qt::RightEdge << Qt::SizeHorCursor;
     QTest::newRow("xdgWmBase - right") << Test::XdgShellSurfaceType::XdgShellStable << Qt::RightEdge << Qt::SizeHorCursor;
     QTest::newRow("xdgShellV6 - bottom") << Test::XdgShellSurfaceType::XdgShellV6 << Qt::BottomEdge << Qt::SizeVerCursor;
     QTest::newRow("xdgWmBase - bottom") << Test::XdgShellSurfaceType::XdgShellStable << Qt::BottomEdge << Qt::SizeVerCursor;
 }
 
 void DecorationInputTest::testResizeOutsideWindow()
 {
     // this test verifies that one can resize the window outside the decoration with NoSideBorder
 
     // first adjust config
     kwinApp()->config()->group("org.kde.kdecoration2").writeEntry("BorderSize", QStringLiteral("None"));
     kwinApp()->config()->sync();
     workspace()->slotReconfigure();
 
     // now create window
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     c->move(screens()->geometry(0).center() - QPoint(c->width()/2, c->height()/2));
     QVERIFY(c->frameGeometry() != c->inputGeometry());
     QVERIFY(c->inputGeometry().contains(c->frameGeometry()));
     QSignalSpy startMoveResizedSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(startMoveResizedSpy.isValid());
 
     // go to border
     quint32 timestamp = 1;
     QFETCH(Qt::Edge, edge);
     switch (edge) {
     case Qt::LeftEdge:
         MOTION(QPoint(c->frameGeometry().x() -1, c->frameGeometry().center().y()));
         break;
     case Qt::RightEdge:
         MOTION(QPoint(c->frameGeometry().x() + c->frameGeometry().width() +1, c->frameGeometry().center().y()));
         break;
     case Qt::BottomEdge:
         MOTION(QPoint(c->frameGeometry().center().x(), c->frameGeometry().y() + c->frameGeometry().height() + 1));
         break;
     default:
         break;
     }
     QVERIFY(!c->frameGeometry().contains(KWin::Cursor::pos()));
 
     // pressing should trigger resize
     PRESS;
     QVERIFY(!c->isResize());
     QVERIFY(startMoveResizedSpy.wait());
     QVERIFY(c->isResize());
 
     RELEASE;
     QVERIFY(!c->isResize());
 }
 
 void DecorationInputTest::testModifierClickUnrestrictedMove_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<int>("mouseButton");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
     QTest::addColumn<Test::XdgShellSurfaceType>("surfaceType");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     const QVector<std::pair<Test::XdgShellSurfaceType, QByteArray>> surfaceTypes{
         { Test::XdgShellSurfaceType::XdgShellV6, QByteArrayLiteral("XdgShellV6") },
         { Test::XdgShellSurfaceType::XdgShellStable, QByteArrayLiteral("XdgWmBase") },
     };
 
     for (const auto &type : surfaceTypes) {
         QTest::newRow("Left Alt + Left Click" + type.second)    << KEY_LEFTALT  << BTN_LEFT   << alt << false << type.first;
         QTest::newRow("Left Alt + Right Click" + type.second)   << KEY_LEFTALT  << BTN_RIGHT  << alt << false << type.first;
         QTest::newRow("Left Alt + Middle Click" + type.second)  << KEY_LEFTALT  << BTN_MIDDLE << alt << false << type.first;
         QTest::newRow("Right Alt + Left Click" + type.second)   << KEY_RIGHTALT << BTN_LEFT   << alt << false << type.first;
         QTest::newRow("Right Alt + Right Click" + type.second)  << KEY_RIGHTALT << BTN_RIGHT  << alt << false << type.first;
         QTest::newRow("Right Alt + Middle Click" + type.second) << KEY_RIGHTALT << BTN_MIDDLE << alt << false << type.first;
         // now everything with meta
         QTest::newRow("Left Meta + Left Click" + type.second)    << KEY_LEFTMETA  << BTN_LEFT   << meta << false << type.first;
         QTest::newRow("Left Meta + Right Click" + type.second)   << KEY_LEFTMETA  << BTN_RIGHT  << meta << false << type.first;
         QTest::newRow("Left Meta + Middle Click" + type.second)  << KEY_LEFTMETA  << BTN_MIDDLE << meta << false << type.first;
         QTest::newRow("Right Meta + Left Click" + type.second)   << KEY_RIGHTMETA << BTN_LEFT   << meta << false << type.first;
         QTest::newRow("Right Meta + Right Click" + type.second)  << KEY_RIGHTMETA << BTN_RIGHT  << meta << false << type.first;
         QTest::newRow("Right Meta + Middle Click" + type.second) << KEY_RIGHTMETA << BTN_MIDDLE << meta << false << type.first;
 
         // and with capslock
         QTest::newRow("Left Alt + Left Click/CapsLock" + type.second)    << KEY_LEFTALT  << BTN_LEFT   << alt << true << type.first;
         QTest::newRow("Left Alt + Right Click/CapsLock" + type.second)   << KEY_LEFTALT  << BTN_RIGHT  << alt << true << type.first;
         QTest::newRow("Left Alt + Middle Click/CapsLock" + type.second)  << KEY_LEFTALT  << BTN_MIDDLE << alt << true << type.first;
         QTest::newRow("Right Alt + Left Click/CapsLock" + type.second)   << KEY_RIGHTALT << BTN_LEFT   << alt << true << type.first;
         QTest::newRow("Right Alt + Right Click/CapsLock" + type.second)  << KEY_RIGHTALT << BTN_RIGHT  << alt << true << type.first;
         QTest::newRow("Right Alt + Middle Click/CapsLock" + type.second) << KEY_RIGHTALT << BTN_MIDDLE << alt << true << type.first;
         // now everything with meta
         QTest::newRow("Left Meta + Left Click/CapsLock" + type.second)    << KEY_LEFTMETA  << BTN_LEFT   << meta << true << type.first;
         QTest::newRow("Left Meta + Right Click/CapsLock" + type.second)   << KEY_LEFTMETA  << BTN_RIGHT  << meta << true << type.first;
         QTest::newRow("Left Meta + Middle Click/CapsLock" + type.second)  << KEY_LEFTMETA  << BTN_MIDDLE << meta << true << type.first;
         QTest::newRow("Right Meta + Left Click/CapsLock" + type.second)   << KEY_RIGHTMETA << BTN_LEFT   << meta << true << type.first;
         QTest::newRow("Right Meta + Right Click/CapsLock" + type.second)  << KEY_RIGHTMETA << BTN_RIGHT  << meta << true << type.first;
         QTest::newRow("Right Meta + Middle Click/CapsLock" + type.second) << KEY_RIGHTMETA << BTN_MIDDLE << meta << true << type.first;
     }
 }
 
 void DecorationInputTest::testModifierClickUnrestrictedMove()
 {
     // this test ensures that Alt+mouse button press triggers unrestricted move
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), modKey == QStringLiteral("Alt") ? Qt::AltModifier : Qt::MetaModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // create a window
     QFETCH(Test::XdgShellSurfaceType, surfaceType);
     AbstractClient *c = showWindow(surfaceType);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     c->move(screens()->geometry(0).center() - QPoint(c->width()/2, c->height()/2));
     // move cursor on window
     Cursor::setPos(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2));
 
     // simulate modifier+click
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     QFETCH(int, mouseButton);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     QVERIFY(!c->isMove());
     kwinApp()->platform()->pointerButtonPressed(mouseButton, timestamp++);
     QVERIFY(c->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     QVERIFY(c->isMove());
     // but releasing the key should end move/resize
     kwinApp()->platform()->pointerButtonReleased(mouseButton, timestamp++);
     QVERIFY(!c->isMove());
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 }
 
 void DecorationInputTest::testModifierScrollOpacity_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
     QTest::addColumn<Test::XdgShellSurfaceType>("surfaceType");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     const QVector<std::pair<Test::XdgShellSurfaceType, QByteArray>> surfaceTypes{
         { Test::XdgShellSurfaceType::XdgShellV6, QByteArrayLiteral("XdgShellV6") },
         { Test::XdgShellSurfaceType::XdgShellStable, QByteArrayLiteral("XdgWmBase") },
     };
 
     for (const auto &type : surfaceTypes) {
         QTest::newRow("Left Alt" + type.second)   << KEY_LEFTALT  << alt << false << type.first;
         QTest::newRow("Right Alt" + type.second)  << KEY_RIGHTALT << alt << false << type.first;
         QTest::newRow("Left Meta" + type.second)  << KEY_LEFTMETA  << meta << false << type.first;
         QTest::newRow("Right Meta" + type.second) << KEY_RIGHTMETA << meta << false << type.first;
         QTest::newRow("Left Alt/CapsLock" + type.second)   << KEY_LEFTALT  << alt << true << type.first;
         QTest::newRow("Right Alt/CapsLock" + type.second)  << KEY_RIGHTALT << alt << true << type.first;
         QTest::newRow("Left Meta/CapsLock" + type.second)  << KEY_LEFTMETA  << meta << true << type.first;
         QTest::newRow("Right Meta/CapsLock" + type.second) << KEY_RIGHTMETA << meta << true << type.first;
     }
 }
 
 void DecorationInputTest::testModifierScrollOpacity()
 {
     // this test verifies that mod+wheel performs a window operation
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     QFETCH(Test::XdgShellSurfaceType, surfaceType);
     AbstractClient *c = showWindow(surfaceType);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     c->move(screens()->geometry(0).center() - QPoint(c->width()/2, c->height()/2));
     // move cursor on window
     Cursor::setPos(QPoint(c->frameGeometry().center().x(), c->y() + c->clientPos().y() / 2));
     // set the opacity to 0.5
     c->setOpacity(0.5);
     QCOMPARE(c->opacity(), 0.5);
 
     // simulate modifier+wheel
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(c->opacity(), 0.6);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(c->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 }
 
 void DecorationInputTest::testTouchEvents_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 class EventHelper : public QObject
 {
     Q_OBJECT
 public:
     EventHelper() : QObject() {}
     ~EventHelper() override = default;
 
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched)
         if (event->type() == QEvent::HoverMove) {
             emit hoverMove();
         } else if (event->type() == QEvent::HoverLeave) {
             emit hoverLeave();
         }
         return false;
     }
 
 Q_SIGNALS:
     void hoverMove();
     void hoverLeave();
 };
 
 void DecorationInputTest::testTouchEvents()
 {
     // this test verifies that the decoration gets a hover leave event on touch release
     // see BUG 386231
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
 
     EventHelper helper;
     c->decoration()->installEventFilter(&helper);
     QSignalSpy hoverMoveSpy(&helper, &EventHelper::hoverMove);
     QVERIFY(hoverMoveSpy.isValid());
     QSignalSpy hoverLeaveSpy(&helper, &EventHelper::hoverLeave);
     QVERIFY(hoverLeaveSpy.isValid());
 
     quint32 timestamp = 1;
     const QPoint tapPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2);
 
     QVERIFY(!input()->touch()->decoration());
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     QVERIFY(input()->touch()->decoration());
     QCOMPARE(input()->touch()->decoration()->decoration(), c->decoration());
     QCOMPARE(hoverMoveSpy.count(), 1);
     QCOMPARE(hoverLeaveSpy.count(), 0);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(hoverMoveSpy.count(), 1);
     QCOMPARE(hoverLeaveSpy.count(), 1);
 
     QCOMPARE(c->isMove(), false);
 
     // let's check that a hover motion is sent if the pointer is on deco, when touch release
     Cursor::setPos(tapPoint);
     QCOMPARE(hoverMoveSpy.count(), 2);
     kwinApp()->platform()->touchDown(0, tapPoint, timestamp++);
     QCOMPARE(hoverMoveSpy.count(), 3);
     QCOMPARE(hoverLeaveSpy.count(), 1);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(hoverMoveSpy.count(), 3);
     QCOMPARE(hoverLeaveSpy.count(), 2);
 }
 
 void DecorationInputTest::testTooltipDoesntEatKeyEvents_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DecorationInputTest::testTooltipDoesntEatKeyEvents()
 {
     // this test verifies that a tooltip on the decoration does not steal key events
     // BUG: 393253
 
     // first create a keyboard
     auto keyboard = Test::waylandSeat()->createKeyboard(Test::waylandSeat());
     QVERIFY(keyboard);
     QSignalSpy enteredSpy(keyboard, &KWayland::Client::Keyboard::entered);
     QVERIFY(enteredSpy.isValid());
 
     QFETCH(Test::XdgShellSurfaceType, type);
     AbstractClient *c = showWindow(type);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     QVERIFY(!c->noBorder());
     QTRY_COMPARE(enteredSpy.count(), 1);
 
     QSignalSpy keyEvent(keyboard, &KWayland::Client::Keyboard::keyChanged);
     QVERIFY(keyEvent.isValid());
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     c->decoratedClient()->requestShowToolTip(QStringLiteral("test"));
     // now we should get an internal window
     QVERIFY(clientAddedSpy.wait());
     InternalClient *internal = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internal->isInternal());
     QVERIFY(internal->internalWindow()->flags().testFlag(Qt::ToolTip));
 
     // now send a key
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QVERIFY(keyEvent.wait());
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QVERIFY(keyEvent.wait());
 
     c->decoratedClient()->requestHideToolTip();
     Test::waitForWindowDestroyed(internal);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DecorationInputTest)
 #include "decoration_input_test.moc"
diff --git a/autotests/integration/desktop_window_x11_test.cpp b/autotests/integration/desktop_window_x11_test.cpp
index 71c4a3123..42525ea63 100644
--- a/autotests/integration/desktop_window_x11_test.cpp
+++ b/autotests/integration/desktop_window_x11_test.cpp
@@ -1,178 +1,177 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "xcbutils.h"
 #include <kwineffects.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_x11_desktop_window-0");
 
 class X11DesktopWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testDesktopWindow();
 
 private:
 };
 
 void X11DesktopWindowTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void X11DesktopWindowTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void X11DesktopWindowTest::cleanup()
 {
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void X11DesktopWindowTest::testDesktopWindow()
 {
     // this test creates a desktop window with an RGBA visual and verifies that it's only considered
     // as an RGB (opaque) window in KWin
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry(0, 0, 1280, 1024);
 
     // helper to find the visual
     auto findDepth = [&c] () -> xcb_visualid_t {
         // find a visual with 32 depth
         const xcb_setup_t *setup = xcb_get_setup(c.data());
 
         for (auto screen = xcb_setup_roots_iterator(setup); screen.rem; xcb_screen_next(&screen)) {
             for (auto depth = xcb_screen_allowed_depths_iterator(screen.data); depth.rem; xcb_depth_next(&depth)) {
                 if (depth.data->depth != 32) {
                     continue;
                 }
                 const int len = xcb_depth_visuals_length(depth.data);
                 const xcb_visualtype_t *visuals = xcb_depth_visuals(depth.data);
 
                 for (int i = 0; i < len; i++) {
                     return visuals[0].visual_id;
                 }
             }
         }
         return 0;
     };
     auto visualId = findDepth();
     auto colormapId = xcb_generate_id(c.data());
     auto cmCookie = xcb_create_colormap_checked(c.data(), XCB_COLORMAP_ALLOC_NONE, colormapId, rootWindow(), visualId);
     QVERIFY(!xcb_request_check(c.data(), cmCookie));
 
     const uint32_t values[] = {XCB_PIXMAP_NONE, defaultScreen()->black_pixel, colormapId};
     auto cookie = xcb_create_window_checked(c.data(), 32, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, visualId, XCB_CW_BACK_PIXMAP | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP, values);
     QVERIFY(!xcb_request_check(c.data(), cookie));
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Desktop);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // verify through a geometry request that it's depth 32
     Xcb::WindowGeometry geo(w);
     QCOMPARE(geo->depth, uint8_t(32));
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->windowType(), NET::Desktop);
     QCOMPARE(client->frameGeometry(), windowGeometry);
     QVERIFY(client->isDesktop());
     QCOMPARE(client->depth(), 24);
     QVERIFY(!client->hasAlpha());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::X11DesktopWindowTest)
 #include "desktop_window_x11_test.moc"
diff --git a/autotests/integration/dont_crash_aurorae_destroy_deco.cpp b/autotests/integration/dont_crash_aurorae_destroy_deco.cpp
index b8d31fde3..dfb5a2ca7 100644
--- a/autotests/integration/dont_crash_aurorae_destroy_deco.cpp
+++ b/autotests/integration/dont_crash_aurorae_destroy_deco.cpp
@@ -1,159 +1,157 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KDecoration2/Decoration>
 
 #include <QQuickItem>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_aurorae_destroy_deco-0");
 
 class DontCrashAuroraeDestroyDecoTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testBorderlessMaximizedWindows();
 
 };
 
 void DontCrashAuroraeDestroyDecoTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("org.kde.kdecoration2").writeEntry("library", "org.kde.kwin.aurorae");
     config->sync();
     kwinApp()->setConfig(config);
 
     // this test needs to enforce OpenGL compositing to get into the crashy condition
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void DontCrashAuroraeDestroyDecoTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void DontCrashAuroraeDestroyDecoTest::testBorderlessMaximizedWindows()
 {
     // this test verifies that Aurorae doesn't crash when clicking the maximize button
     // with kwin config option BorderlessMaximizedWindows
     // see BUG 362772
 
     // first adjust the config
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", true);
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), true);
 
     // create an xcb window
     xcb_connection_t *c = xcb_connect(nullptr, nullptr);
     QVERIFY(!xcb_connection_has_error(c));
 
     xcb_window_t w = xcb_generate_id(c);
     xcb_create_window(c, XCB_COPY_FROM_PARENT, w, rootWindow(), 0, 0, 100, 200, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_map_window(c, w);
     xcb_flush(c);
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QCOMPARE(client->maximizeMode(), MaximizeRestore);
     QCOMPARE(client->noBorder(), false);
     // verify that the deco is Aurorae
     QCOMPARE(qstrcmp(client->decoration()->metaObject()->className(), "Aurorae::Decoration"), 0);
     // find the maximize button
     QQuickItem *item = client->decoration()->findChild<QQuickItem*>("maximizeButton");
     QVERIFY(item);
     const QPointF scenePoint = item->mapToScene(QPoint(0, 0));
 
     // mark the window as ready for painting, otherwise it doesn't get input events
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
 
     // simulate click on maximize button
     QSignalSpy maximizedStateChangedSpy(client, static_cast<void (AbstractClient::*)(KWin::AbstractClient*, MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged));
     QVERIFY(maximizedStateChangedSpy.isValid());
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(client->frameGeometry().topLeft() + scenePoint.toPoint(), timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(maximizedStateChangedSpy.wait());
     QCOMPARE(client->maximizeMode(), MaximizeFull);
     QCOMPARE(client->noBorder(), true);
 
     // and destroy the window again
     xcb_unmap_window(c, w);
     xcb_destroy_window(c, w);
     xcb_flush(c);
     xcb_disconnect(c);
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DontCrashAuroraeDestroyDecoTest)
 #include "dont_crash_aurorae_destroy_deco.moc"
diff --git a/autotests/integration/dont_crash_cancel_animation.cpp b/autotests/integration/dont_crash_cancel_animation.cpp
index defa6d6e2..790aecb59 100644
--- a/autotests/integration/dont_crash_cancel_animation.cpp
+++ b/autotests/integration/dont_crash_cancel_animation.cpp
@@ -1,125 +1,123 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "x11client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "scripting/scriptedeffect.h"
 
 #include <KDecoration2/Decoration>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_cancel_animation-0");
 
 class DontCrashCancelAnimationFromAnimationEndedTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testScript();
 };
 
 void DontCrashCancelAnimationFromAnimationEndedTest::initTestCase()
 {
     qRegisterMetaType<KWin::Deleted*>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     kwinApp()->start();
     QVERIFY(Compositor::self());
     QSignalSpy compositorToggledSpy(Compositor::self(), &Compositor::compositingToggled);
     QVERIFY(compositorToggledSpy.isValid());
     QVERIFY(compositorToggledSpy.wait());
     QVERIFY(effects);
 }
 
 void DontCrashCancelAnimationFromAnimationEndedTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void DontCrashCancelAnimationFromAnimationEndedTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DontCrashCancelAnimationFromAnimationEndedTest::testScript()
 {
     // load a scripted effect which deletes animation data
     ScriptedEffect *effect = ScriptedEffect::create(QStringLiteral("crashy"), QFINDTESTDATA("data/anim-data-delete-effect/effect.js"), 10);
     QVERIFY(effect);
 
     const auto children = effects->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "KWin::EffectLoader") != 0) {
             continue;
         }
         QVERIFY(QMetaObject::invokeMethod(*it, "effectLoaded", Q_ARG(KWin::Effect*, effect), Q_ARG(QString, QStringLiteral("crashy"))));
         break;
     }
     QVERIFY(static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded(QStringLiteral("crashy")));
 
     using namespace KWayland::Client;
     // create a window
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     // let's render
     auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // make sure we animate
     QTest::qWait(200);
 
     // wait for the window to be passed to Deleted
     QSignalSpy windowDeletedSpy(c, &AbstractClient::windowClosed);
     QVERIFY(windowDeletedSpy.isValid());
 
     surface->deleteLater();
 
     QVERIFY(windowDeletedSpy.wait());
     // make sure we animate
     QTest::qWait(200);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DontCrashCancelAnimationFromAnimationEndedTest)
 #include "dont_crash_cancel_animation.moc"
diff --git a/autotests/integration/dont_crash_cursor_physical_size_empty.cpp b/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
index 50fbbabb5..69c105b9c 100644
--- a/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
+++ b/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
@@ -1,122 +1,120 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Martin Flöser <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 "kwin_wayland_test.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "effects.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/output_interface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_crash_cursor_physical_size_empty-0");
 
 class DontCrashCursorPhysicalSizeEmpty : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void init();
     void initTestCase();
     void cleanup();
     void testMoveCursorOverDeco_data();
     void testMoveCursorOverDeco();
 };
 
 void DontCrashCursorPhysicalSizeEmpty::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(640, 512));
 }
 
 void DontCrashCursorPhysicalSizeEmpty::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DontCrashCursorPhysicalSizeEmpty::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("0"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
 }
 
 void DontCrashCursorPhysicalSizeEmpty::testMoveCursorOverDeco_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DontCrashCursorPhysicalSizeEmpty::testMoveCursorOverDeco()
 {
     // This test ensures that there is no endless recursion if the cursor theme cannot be created
     // a reason for creation failure could be physical size not existing
     // see BUG: 390314
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     Test::waylandServerSideDecoration()->create(surface.data(), surface.data());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
 
     // destroy physical size
     KWayland::Server::Display *display = waylandServer()->display();
     auto output = display->outputs().first();
     output->setPhysicalSize(QSize(0, 0));
     // and fake a cursor theme change, so that the theme gets recreated
     emit KWin::Cursor::self()->themeChanged();
 
     KWin::Cursor::setPos(QPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2));
 }
 
 WAYLANDTEST_MAIN(DontCrashCursorPhysicalSizeEmpty)
 #include "dont_crash_cursor_physical_size_empty.moc"
diff --git a/autotests/integration/dont_crash_empty_deco.cpp b/autotests/integration/dont_crash_empty_deco.cpp
index e995c61c6..6520175af 100644
--- a/autotests/integration/dont_crash_empty_deco.cpp
+++ b/autotests/integration/dont_crash_empty_deco.cpp
@@ -1,124 +1,122 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "scene.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KDecoration2/Decoration>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_empty_decoration-0");
 
 class DontCrashEmptyDecorationTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testBug361551();
 };
 
 void DontCrashEmptyDecorationTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // this test needs to enforce OpenGL compositing to get into the crashy condition
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void DontCrashEmptyDecorationTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void DontCrashEmptyDecorationTest::testBug361551()
 {
     // this test verifies that resizing an X11 window to an invalid size does not result in crash on unmap
     // when the DecorationRenderer gets copied to the Deleted
     // there a repaint is scheduled and the resulting texture is invalid if the window size is invalid
 
     // create an xcb window
     xcb_connection_t *c = xcb_connect(nullptr, nullptr);
     QVERIFY(!xcb_connection_has_error(c));
 
     xcb_window_t w = xcb_generate_id(c);
     xcb_create_window(c, XCB_COPY_FROM_PARENT, w, rootWindow(), 0, 0, 10, 10, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_map_window(c, w);
     xcb_flush(c);
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
 
     // let's set a stupid geometry
     client->setFrameGeometry(0, 0, 0, 0);
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 0, 0));
 
     // and destroy the window again
     xcb_unmap_window(c, w);
     xcb_destroy_window(c, w);
     xcb_flush(c);
     xcb_disconnect(c);
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DontCrashEmptyDecorationTest)
 #include "dont_crash_empty_deco.moc"
diff --git a/autotests/integration/dont_crash_no_border.cpp b/autotests/integration/dont_crash_no_border.cpp
index a014b4f55..efe12f053 100644
--- a/autotests/integration/dont_crash_no_border.cpp
+++ b/autotests/integration/dont_crash_no_border.cpp
@@ -1,135 +1,133 @@
 
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "scene.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/surface.h>
 
 #include <KDecoration2/Decoration>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_no_border-0");
 
 class DontCrashNoBorder : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testCreateWindow_data();
     void testCreateWindow();
 };
 
 void DontCrashNoBorder::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("org.kde.kdecoration2").writeEntry("NoPlugin", true);
     config->sync();
     kwinApp()->setConfig(config);
 
     // this test needs to enforce OpenGL compositing to get into the crashy condition
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void DontCrashNoBorder::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void DontCrashNoBorder::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DontCrashNoBorder::testCreateWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DontCrashNoBorder::testCreateWindow()
 {
     // create a window and ensure that this doesn't crash
         using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(shellSurface);
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(500, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(!c->isDecorated());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::DontCrashNoBorder)
 #include "dont_crash_no_border.moc"
diff --git a/autotests/integration/dont_crash_reinitialize_compositor.cpp b/autotests/integration/dont_crash_reinitialize_compositor.cpp
index f4000487e..d75b769b1 100644
--- a/autotests/integration/dont_crash_reinitialize_compositor.cpp
+++ b/autotests/integration/dont_crash_reinitialize_compositor.cpp
@@ -1,169 +1,167 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_reinitialize_compositor-0");
 
 class DontCrashReinitializeCompositorTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testReinitializeCompositor_data();
     void testReinitializeCompositor();
 };
 
 void DontCrashReinitializeCompositorTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::Deleted *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void DontCrashReinitializeCompositorTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void DontCrashReinitializeCompositorTest::cleanup()
 {
     // Unload all effects.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     Test::destroyWaylandConnection();
 }
 
 void DontCrashReinitializeCompositorTest::testReinitializeCompositor_data()
 {
     QTest::addColumn<QString>("effectName");
 
     QTest::newRow("Fade")   << QStringLiteral("kwin4_effect_fade");
     QTest::newRow("Glide")  << QStringLiteral("glide");
     QTest::newRow("Scale")  << QStringLiteral("kwin4_effect_scale");
 }
 
 void DontCrashReinitializeCompositorTest::testReinitializeCompositor()
 {
     // This test verifies that KWin doesn't crash when the compositor settings
     // have been changed while a scripted effect animates the disappearing of
     // a window.
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Create the test client.
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Make sure that only the test effect is loaded.
     QFETCH(QString, effectName);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Close the test client.
-    QSignalSpy windowClosedSpy(client, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(client, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
 
     // The test effect should start animating the test client. Is there a better
     // way to verify that the test effect actually animates the test client?
     QVERIFY(effect->isActive());
 
     // Re-initialize the compositor, effects will be destroyed and created again.
     Compositor::self()->reinitialize();
 
     // By this time, KWin should still be alive.
 }
 
 } // namespace KWin
 
 WAYLANDTEST_MAIN(KWin::DontCrashReinitializeCompositorTest)
 #include "dont_crash_reinitialize_compositor.moc"
diff --git a/autotests/integration/dont_crash_useractions_menu.cpp b/autotests/integration/dont_crash_useractions_menu.cpp
index d105d7267..86cd72c41 100644
--- a/autotests/integration/dont_crash_useractions_menu.cpp
+++ b/autotests/integration/dont_crash_useractions_menu.cpp
@@ -1,116 +1,115 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "keyboard_input.h"
 #include "platform.h"
 #include "pointer_input.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "useractions.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_dont_crash_useractions_menu-0");
 
 class TestDontCrashUseractionsMenu : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testShowHideShowUseractionsMenu();
 };
 
 void TestDontCrashUseractionsMenu::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // force style to breeze as that's the one which triggered the crash
     QVERIFY(kwinApp()->setStyle(QStringLiteral("breeze")));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestDontCrashUseractionsMenu::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestDontCrashUseractionsMenu::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestDontCrashUseractionsMenu::testShowHideShowUseractionsMenu()
 {
     // this test creates the condition of BUG 382063
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto client = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     workspace()->showWindowMenu(QRect(), client);
     auto userActionsMenu = workspace()->userActionsMenu();
     QTRY_VERIFY(userActionsMenu->isShown());
     QVERIFY(userActionsMenu->hasClient());
 
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, 1);
     QTRY_VERIFY(!userActionsMenu->isShown());
     QVERIFY(!userActionsMenu->hasClient());
 
     // and show again, this triggers BUG 382063
     workspace()->showWindowMenu(QRect(), client);
     QTRY_VERIFY(userActionsMenu->isShown());
     QVERIFY(userActionsMenu->hasClient());
 }
 
 WAYLANDTEST_MAIN(TestDontCrashUseractionsMenu)
 #include "dont_crash_useractions_menu.moc"
diff --git a/autotests/integration/effects/desktop_switching_animation_test.cpp b/autotests/integration/effects/desktop_switching_animation_test.cpp
index 2549b043e..c3736047c 100644
--- a/autotests/integration/effects/desktop_switching_animation_test.cpp
+++ b/autotests/integration/effects/desktop_switching_animation_test.cpp
@@ -1,163 +1,161 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_desktop_switching_animation-0");
 
 class DesktopSwitchingAnimationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testSwitchDesktops_data();
     void testSwitchDesktops();
 };
 
 void DesktopSwitchingAnimationTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), OpenGL2Compositing);
 }
 
 void DesktopSwitchingAnimationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void DesktopSwitchingAnimationTest::cleanup()
 {
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     VirtualDesktopManager::self()->setCount(1);
 
     Test::destroyWaylandConnection();
 }
 
 void DesktopSwitchingAnimationTest::testSwitchDesktops_data()
 {
     QTest::addColumn<QString>("effectName");
 
     QTest::newRow("Desktop Cube Animation") << QStringLiteral("cubeslide");
     QTest::newRow("Fade Desktop")           << QStringLiteral("kwin4_effect_fadedesktop");
     QTest::newRow("Slide")                  << QStringLiteral("slide");
 }
 
 void DesktopSwitchingAnimationTest::testSwitchDesktops()
 {
     // This test verifies that virtual desktop switching animation effects actually
     // try to animate switching between desktops.
 
     // We need at least 2 virtual desktops for the test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1u);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // The Fade Desktop effect will do nothing if there are no clients to fade,
     // so we have to create a dummy test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QCOMPARE(client->desktops().count(), 1);
     QCOMPARE(client->desktops().first(), VirtualDesktopManager::self()->desktops().first());
 
     // Load effect that will be tested.
     QFETCH(QString, effectName);
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Switch to the second virtual desktop.
     VirtualDesktopManager::self()->setCurrent(2u);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2u);
     QVERIFY(effect->isActive());
     QCOMPARE(effects->activeFullScreenEffect(), effect);
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
     QTRY_COMPARE(effects->activeFullScreenEffect(), nullptr);
 
     // Destroy the test client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(DesktopSwitchingAnimationTest)
 #include "desktop_switching_animation_test.moc"
diff --git a/autotests/integration/effects/fade_test.cpp b/autotests/integration/effects/fade_test.cpp
index bcba46f19..2be6b66a8 100644
--- a/autotests/integration/effects/fade_test.cpp
+++ b/autotests/integration/effects/fade_test.cpp
@@ -1,181 +1,180 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "composite.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Client/surface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 static const QString s_socketName = QStringLiteral("wayland_test_effects_translucency-0");
 
 class FadeTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testWindowCloseAfterWindowHidden_data();
     void testWindowCloseAfterWindowHidden();
 
 private:
     Effect *m_fadeEffect = nullptr;
 };
 
 void FadeTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 }
 
 void FadeTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 
     // load the translucency effect
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     // find the effectsloader
     auto effectloader = e->findChild<AbstractEffectLoader*>();
     QVERIFY(effectloader);
     QSignalSpy effectLoadedSpy(effectloader, &AbstractEffectLoader::effectLoaded);
     QVERIFY(effectLoadedSpy.isValid());
 
     QVERIFY(!e->isEffectLoaded(QStringLiteral("kwin4_effect_fade")));
     QVERIFY(e->loadEffect(QStringLiteral("kwin4_effect_fade")));
     QVERIFY(e->isEffectLoaded(QStringLiteral("kwin4_effect_fade")));
 
     QCOMPARE(effectLoadedSpy.count(), 1);
     m_fadeEffect = effectLoadedSpy.first().first().value<Effect*>();
     QVERIFY(m_fadeEffect);
 }
 
 void FadeTest::cleanup()
 {
     Test::destroyWaylandConnection();
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     if (e->isEffectLoaded(QStringLiteral("kwin4_effect_fade"))) {
         e->unloadEffect(QStringLiteral("kwin4_effect_fade"));
     }
     QVERIFY(!e->isEffectLoaded(QStringLiteral("kwin4_effect_fade")));
     m_fadeEffect = nullptr;
 }
 
 void FadeTest::testWindowCloseAfterWindowHidden_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void FadeTest::testWindowCloseAfterWindowHidden()
 {
     // this test simulates the showing/hiding/closing of a Wayland window
     // especially the situation that a window got unmapped and destroyed way later
     QVERIFY(!m_fadeEffect->isActive());
 
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
     QSignalSpy windowHiddenSpy(effects, &EffectsHandler::windowHidden);
     QVERIFY(windowHiddenSpy.isValid());
     QSignalSpy windowShownSpy(effects, &EffectsHandler::windowShown);
     QVERIFY(windowShownSpy.isValid());
     QSignalSpy windowClosedSpy(effects, &EffectsHandler::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QTRY_COMPARE(windowAddedSpy.count(), 1);
     QTRY_COMPARE(m_fadeEffect->isActive(), true);
 
     QTest::qWait(500);
     QTRY_COMPARE(m_fadeEffect->isActive(), false);
 
     // now unmap the surface
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(windowHiddenSpy.wait());
     QCOMPARE(m_fadeEffect->isActive(), true);
     QTest::qWait(500);
     QTRY_COMPARE(m_fadeEffect->isActive(), false);
 
     // and map again
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(windowShownSpy.wait());
     QTRY_COMPARE(m_fadeEffect->isActive(), true);
     QTest::qWait(500);
     QTRY_COMPARE(m_fadeEffect->isActive(), false);
 
     // and unmap once more
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(windowHiddenSpy.wait());
     QCOMPARE(m_fadeEffect->isActive(), true);
     QTest::qWait(500);
     QTRY_COMPARE(m_fadeEffect->isActive(), false);
 
     // and now destroy
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
     QCOMPARE(m_fadeEffect->isActive(), false);
 }
 
 WAYLANDTEST_MAIN(FadeTest)
 #include "fade_test.moc"
diff --git a/autotests/integration/effects/maximize_animation_test.cpp b/autotests/integration/effects/maximize_animation_test.cpp
index 5d0f75607..e84d8ae57 100644
--- a/autotests/integration/effects/maximize_animation_test.cpp
+++ b/autotests/integration/effects/maximize_animation_test.cpp
@@ -1,212 +1,210 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_maximize_animation-0");
 
 class MaximizeAnimationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMaximizeRestore_data();
     void testMaximizeRestore();
 };
 
 void MaximizeAnimationTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void MaximizeAnimationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void MaximizeAnimationTest::cleanup()
 {
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     Test::destroyWaylandConnection();
 }
 
 void MaximizeAnimationTest::testMaximizeRestore_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase")  << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void MaximizeAnimationTest::testMaximizeRestore()
 {
     // This test verifies that the maximize effect animates a client
     // when it's maximized or restored.
 
     using namespace KWayland::Client;
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(createXdgShellSurface(type, surface.data(), nullptr, Test::CreationSetup::CreateOnly));
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), QSize(0, 0));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Draw contents of the surface.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Load effect that will be tested.
     const QString effectName = QStringLiteral("kwin4_effect_maximize");
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Maximize the client.
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
-    QSignalSpy maximizeChangedSpy(client, qOverload<AbstractClient *, bool, bool>(&XdgShellClient::clientMaximizedStateChanged));
+    QSignalSpy maximizeChangedSpy(client, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged));
     QVERIFY(maximizeChangedSpy.isValid());
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), QSize(1280, 1024));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Draw contents of the maximized client.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(maximizeChangedSpy.count(), 1);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Restore the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     QCOMPARE(configureRequestedSpy.last().at(0).value<QSize>(), QSize(100, 50));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Draw contents of the restored client.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 2);
     QCOMPARE(maximizeChangedSpy.count(), 2);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the test client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(MaximizeAnimationTest)
 #include "maximize_animation_test.moc"
diff --git a/autotests/integration/effects/minimize_animation_test.cpp b/autotests/integration/effects/minimize_animation_test.cpp
index db39de827..c4e2086f5 100644
--- a/autotests/integration/effects/minimize_animation_test.cpp
+++ b/autotests/integration/effects/minimize_animation_test.cpp
@@ -1,198 +1,196 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_minimize_animation-0");
 
 class MinimizeAnimationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMinimizeUnminimize_data();
     void testMinimizeUnminimize();
 };
 
 void MinimizeAnimationTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), OpenGL2Compositing);
 }
 
 void MinimizeAnimationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(
         Test::AdditionalWaylandInterface::PlasmaShell |
         Test::AdditionalWaylandInterface::WindowManagement
     ));
 }
 
 void MinimizeAnimationTest::cleanup()
 {
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     Test::destroyWaylandConnection();
 }
 
 void MinimizeAnimationTest::testMinimizeUnminimize_data()
 {
     QTest::addColumn<QString>("effectName");
 
     QTest::newRow("Magic Lamp") << QStringLiteral("magiclamp");
     QTest::newRow("Squash")     << QStringLiteral("kwin4_effect_squash");
 }
 
 void MinimizeAnimationTest::testMinimizeUnminimize()
 {
     // This test verifies that a minimize effect tries to animate a client
     // when it's minimized or unminimized.
 
     using namespace KWayland::Client;
 
     QSignalSpy plasmaWindowCreatedSpy(Test::waylandWindowManagement(), &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // Create a panel at the top of the screen.
     const QRect panelRect = QRect(0, 0, 1280, 36);
     QScopedPointer<Surface> panelSurface(Test::createSurface());
     QVERIFY(!panelSurface.isNull());
     QScopedPointer<XdgShellSurface> panelShellSurface(Test::createXdgShellStableSurface(panelSurface.data()));
     QVERIFY(!panelShellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaPanelShellSurface(Test::waylandPlasmaShell()->createSurface(panelSurface.data()));
     QVERIFY(!plasmaPanelShellSurface.isNull());
     plasmaPanelShellSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaPanelShellSurface->setPosition(panelRect.topLeft());
     plasmaPanelShellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AlwaysVisible);
-    XdgShellClient *panel = Test::renderAndWaitForShown(panelSurface.data(), panelRect.size(), Qt::blue);
+    AbstractClient *panel = Test::renderAndWaitForShown(panelSurface.data(), panelRect.size(), Qt::blue);
     QVERIFY(panel);
     QVERIFY(panel->isDock());
     QCOMPARE(panel->frameGeometry(), panelRect);
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(client);
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 2);
 
     // We have to set the minimized geometry because the squash effect needs it,
     // otherwise it won't start animation.
     auto window = plasmaWindowCreatedSpy.last().first().value<PlasmaWindow *>();
     QVERIFY(window);
     const QRect iconRect = QRect(0, 0, 42, 36);
     window->setMinimizedGeometry(panelSurface.data(), iconRect);
     Test::flushWaylandConnection();
     QTRY_COMPARE(client->iconGeometry(), iconRect.translated(panel->frameGeometry().topLeft()));
 
     // Load effect that will be tested.
     QFETCH(QString, effectName);
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Start the minimize animation.
     client->minimize();
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Start the unminimize animation.
     client->unminimize();
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the panel.
     panelSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(panel));
 
     // Destroy the test client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(MinimizeAnimationTest)
 #include "minimize_animation_test.moc"
diff --git a/autotests/integration/effects/popup_open_close_animation_test.cpp b/autotests/integration/effects/popup_open_close_animation_test.cpp
index 349fa2dae..a1b8df54a 100644
--- a/autotests/integration/effects/popup_open_close_animation_test.cpp
+++ b/autotests/integration/effects/popup_open_close_animation_test.cpp
@@ -1,280 +1,278 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "deleted.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "useractions.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "decorations/decoratedclient.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/xdgshell.h>
 
 #include <linux/input.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_popup_open_close_animation-0");
 
 class PopupOpenCloseAnimationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testAnimatePopups();
     void testAnimateUserActionsPopup();
     void testAnimateDecorationTooltips();
 };
 
 void PopupOpenCloseAnimationTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::Deleted *>();
     qRegisterMetaType<KWin::InternalClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void PopupOpenCloseAnimationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::XdgDecoration));
 }
 
 void PopupOpenCloseAnimationTest::cleanup()
 {
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     Test::destroyWaylandConnection();
 }
 
 void PopupOpenCloseAnimationTest::testAnimatePopups()
 {
     // This test verifies that popup open/close animation effects try
     // to animate popups(e.g. popup menus, tooltips, etc).
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Create the main window.
     using namespace KWayland::Client;
     QScopedPointer<Surface> mainWindowSurface(Test::createSurface());
     QVERIFY(!mainWindowSurface.isNull());
     QScopedPointer<XdgShellSurface> mainWindowShellSurface(Test::createXdgShellStableSurface(mainWindowSurface.data()));
     QVERIFY(!mainWindowShellSurface.isNull());
-    XdgShellClient *mainWindow = Test::renderAndWaitForShown(mainWindowSurface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *mainWindow = Test::renderAndWaitForShown(mainWindowSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(mainWindow);
 
     // Load effect that will be tested.
     const QString effectName = QStringLiteral("kwin4_effect_fadingpopups");
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Create a popup, it should be animated.
     QScopedPointer<Surface> popupSurface(Test::createSurface());
     QVERIFY(!popupSurface.isNull());
     XdgPositioner positioner(QSize(20, 20), QRect(0, 0, 10, 10));
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::LeftEdge);
     QScopedPointer<XdgShellPopup> popupShellSurface(Test::createXdgShellStablePopup(popupSurface.data(), mainWindowShellSurface.data(), positioner));
     QVERIFY(!popupShellSurface.isNull());
-    XdgShellClient *popup = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::red);
+    AbstractClient *popup = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::red);
     QVERIFY(popup);
     QVERIFY(popup->isPopupWindow());
     QCOMPARE(popup->transientFor(), mainWindow);
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the popup, it should not be animated.
-    QSignalSpy popupClosedSpy(popup, &XdgShellClient::windowClosed);
+    QSignalSpy popupClosedSpy(popup, &AbstractClient::windowClosed);
     QVERIFY(popupClosedSpy.isValid());
     popupShellSurface.reset();
     popupSurface.reset();
     QVERIFY(popupClosedSpy.wait());
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the main window.
     mainWindowSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(mainWindow));
 }
 
 void PopupOpenCloseAnimationTest::testAnimateUserActionsPopup()
 {
     // This test verifies that popup open/close animation effects try
     // to animate the user actions popup.
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Load effect that will be tested.
     const QString effectName = QStringLiteral("kwin4_effect_fadingpopups");
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Show the user actions popup.
     workspace()->showWindowMenu(QRect(), client);
     auto userActionsMenu = workspace()->userActionsMenu();
     QTRY_VERIFY(userActionsMenu->isShown());
     QVERIFY(userActionsMenu->hasClient());
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Close the user actions popup.
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, 1);
     QTRY_VERIFY(!userActionsMenu->isShown());
     QVERIFY(!userActionsMenu->hasClient());
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the test client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void PopupOpenCloseAnimationTest::testAnimateDecorationTooltips()
 {
     // This test verifies that popup open/close animation effects try
     // to animate decoration tooltips.
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
     QVERIFY(!deco.isNull());
     deco->setMode(XdgDecoration::Mode::ServerSide);
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     // Load effect that will be tested.
     const QString effectName = QStringLiteral("kwin4_effect_fadingpopups");
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Show a decoration tooltip.
     QSignalSpy tooltipAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(tooltipAddedSpy.isValid());
     client->decoratedClient()->requestShowToolTip(QStringLiteral("KWin rocks!"));
     QVERIFY(tooltipAddedSpy.wait());
     InternalClient *tooltip = tooltipAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(tooltip->isInternal());
     QVERIFY(tooltip->isPopupWindow());
     QVERIFY(tooltip->internalWindow()->flags().testFlag(Qt::ToolTip));
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Hide the decoration tooltip.
     QSignalSpy tooltipClosedSpy(tooltip, &InternalClient::windowClosed);
     QVERIFY(tooltipClosedSpy.isValid());
     client->decoratedClient()->requestHideToolTip();
     QVERIFY(tooltipClosedSpy.wait());
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Destroy the test client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(PopupOpenCloseAnimationTest)
 #include "popup_open_close_animation_test.moc"
diff --git a/autotests/integration/effects/scripted_effects_test.cpp b/autotests/integration/effects/scripted_effects_test.cpp
index a6739a2f6..a159fc54f 100644
--- a/autotests/integration/effects/scripted_effects_test.cpp
+++ b/autotests/integration/effects/scripted_effects_test.cpp
@@ -1,792 +1,791 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 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 <https://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "scripting/scriptedeffect.h"
 #include "libkwineffects/anidata_p.h"
 
+#include "abstract_client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "effect_builtins.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "kwin_wayland_test.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <QScriptContext>
 #include <QScriptEngine>
 #include <QScriptValue>
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/slide.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 using namespace std::chrono_literals;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_scripts-0");
 
 class ScriptedEffectsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testEffectsHandler();
     void testEffectsContext();
     void testShortcuts();
     void testAnimations_data();
     void testAnimations();
     void testScreenEdge();
     void testScreenEdgeTouch();
     void testFullScreenEffect_data();
     void testFullScreenEffect();
     void testKeepAlive_data();
     void testKeepAlive();
     void testGrab();
     void testGrabAlreadyGrabbedWindow();
     void testGrabAlreadyGrabbedWindowForced();
     void testUngrab();
     void testRedirect_data();
     void testRedirect();
     void testComplete();
 
 private:
     ScriptedEffect *loadEffect(const QString &name);
 };
 
 class ScriptedEffectWithDebugSpy : public KWin::ScriptedEffect
 {
     Q_OBJECT
 public:
     ScriptedEffectWithDebugSpy();
     bool load(const QString &name);
     using AnimationEffect::AniMap;
     using AnimationEffect::state;
 signals:
     void testOutput(const QString &data);
 };
 
 QScriptValue kwinEffectScriptTestOut(QScriptContext *context, QScriptEngine *engine)
 {
     auto *script = qobject_cast<ScriptedEffectWithDebugSpy*>(context->callee().data().toQObject());
     QString result;
     for (int i = 0; i < context->argumentCount(); ++i) {
         if (i > 0) {
             result.append(QLatin1Char(' '));
         }
         result.append(context->argument(i).toString());
     }
     emit script->testOutput(result);
 
     return engine->undefinedValue();
 }
 
 ScriptedEffectWithDebugSpy::ScriptedEffectWithDebugSpy()
     : ScriptedEffect()
 {
     QScriptValue testHookFunc = engine()->newFunction(kwinEffectScriptTestOut);
     testHookFunc.setData(engine()->newQObject(this));
     engine()->globalObject().setProperty(QStringLiteral("sendTestResponse"), testHookFunc);
 }
 
 bool ScriptedEffectWithDebugSpy::load(const QString &name)
 {
     const QString path = QFINDTESTDATA("./scripts/" + name + ".js");
     if (!init(name, path)) {
         return false;
     }
 
     // inject our newly created effect to be registered with the EffectsHandlerImpl::loaded_effects
     // this is private API so some horrible code is used to find the internal effectloader
     // and register ourselves
     auto c = effects->children();
     for (auto it = c.begin(); it != c.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "KWin::EffectLoader") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "effectLoaded", Q_ARG(KWin::Effect*, this), Q_ARG(QString, name));
         break;
     }
 
     return (static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded(name));
 }
 
 void ScriptedEffectsTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     ScriptedEffectLoader loader;
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 
     KWin::VirtualDesktopManager::self()->setCount(2);
 }
 
 void ScriptedEffectsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void ScriptedEffectsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     auto effectsImpl = static_cast<EffectsHandlerImpl *>(effects);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     KWin::VirtualDesktopManager::self()->setCurrent(1);
 }
 
 void ScriptedEffectsTest::testEffectsHandler()
 {
     // this triggers and tests some of the signals in EffectHandler, which is exposed to JS as context property "effects"
     auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     auto waitFor = [&effectOutputSpy, this](const QString &expected) {
         QVERIFY(effectOutputSpy.count() > 0 || effectOutputSpy.wait());
         QCOMPARE(effectOutputSpy.first().first(), expected);
         effectOutputSpy.removeFirst();
     };
     QVERIFY(effect->load("effectsHandler"));
 
     // trigger windowAdded signal
 
     // create a window
     using namespace KWayland::Client;
     auto *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
     QVERIFY(shellSurface);
     shellSurface->setTitle("WindowA");
     auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     waitFor("windowAdded - WindowA");
     waitFor("stackingOrder - 1 WindowA");
 
     // windowMinimsed
     c->minimize();
     waitFor("windowMinimized - WindowA");
 
     c->unminimize();
     waitFor("windowUnminimized - WindowA");
 
     surface->deleteLater();
     waitFor("windowClosed - WindowA");
 
     // desktop management
     KWin::VirtualDesktopManager::self()->setCurrent(2);
     waitFor("desktopChanged - 1 2");
 }
 
 void ScriptedEffectsTest::testEffectsContext()
 {
     // this tests misc non-objects exposed to the script engine: animationTime, displaySize, use of external enums
 
     auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effect->load("effectContext"));
     QCOMPARE(effectOutputSpy[0].first(), "1280x1024");
     QCOMPARE(effectOutputSpy[1].first(), "100");
     QCOMPARE(effectOutputSpy[2].first(), "2");
     QCOMPARE(effectOutputSpy[3].first(), "0");
 }
 
 void ScriptedEffectsTest::testShortcuts()
 {
     // this tests method registerShortcut
     auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effect->load("shortcutsTest"));
     QCOMPARE(effect->shortcutCallbacks().count(), 1);
     QAction *action = effect->shortcutCallbacks().keys()[0];
     QCOMPARE(action->objectName(), "testShortcut");
     QCOMPARE(action->text(), "Test Shortcut");
     QCOMPARE(KGlobalAccel::self()->shortcut(action).first(), QKeySequence("Meta+Shift+Y"));
     action->trigger();
     QCOMPARE(effectOutputSpy[0].first(), "shortcutTriggered");
 }
 
 void ScriptedEffectsTest::testAnimations_data()
 {
     QTest::addColumn<QString>("file");
     QTest::addColumn<int>("animationCount");
 
     QTest::newRow("single") << "animationTest" << 1;
     QTest::newRow("multi")  << "animationTestMulti" << 2;
 }
 
 void ScriptedEffectsTest::testAnimations()
 {
     // this tests animate/set/cancel
     // methods take either an int or an array, as forced in the data above
     // also splits animate vs effects.animate(..)
 
     QFETCH(QString, file);
     QFETCH(int, animationCount);
 
     auto *effect = new ScriptedEffectWithDebugSpy;
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effect->load(file));
 
     // animated after window added connect
     using namespace KWayland::Client;
     auto *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
     QVERIFY(shellSurface);
     shellSurface->setTitle("Window 1");
     auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const auto &animationsForWindow = state.first().first;
         QCOMPARE(animationsForWindow.count(), animationCount);
         QCOMPARE(animationsForWindow[0].timeLine.duration(), 100ms);
         QCOMPARE(animationsForWindow[0].to, FPx2(1.4));
         QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
         QCOMPARE(animationsForWindow[0].timeLine.easingCurve().type(), QEasingCurve::OutQuad);
         QCOMPARE(animationsForWindow[0].terminationFlags,
                  AnimationEffect::TerminateAtSource | AnimationEffect::TerminateAtTarget);
 
         if (animationCount == 2) {
             QCOMPARE(animationsForWindow[1].timeLine.duration(), 100ms);
             QCOMPARE(animationsForWindow[1].to, FPx2(0.0));
             QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
             QCOMPARE(animationsForWindow[1].terminationFlags,
                      AnimationEffect::TerminateAtSource | AnimationEffect::TerminateAtTarget);
         }
     }
     QCOMPARE(effectOutputSpy[0].first(), "true");
 
     // window state changes, scale should be retargetted
 
     c->setMinimized(true);
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         const auto &animationsForWindow = state.first().first;
         QCOMPARE(animationsForWindow.count(), animationCount);
         QCOMPARE(animationsForWindow[0].timeLine.duration(), 200ms);
         QCOMPARE(animationsForWindow[0].to, FPx2(1.5));
         QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
         QCOMPARE(animationsForWindow[0].terminationFlags,
                  AnimationEffect::TerminateAtSource | AnimationEffect::TerminateAtTarget);
         if (animationCount == 2) {
             QCOMPARE(animationsForWindow[1].timeLine.duration(), 200ms);
             QCOMPARE(animationsForWindow[1].to, FPx2(1.5));
             QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
             QCOMPARE(animationsForWindow[1].terminationFlags,
                      AnimationEffect::TerminateAtSource | AnimationEffect::TerminateAtTarget);
         }
     }
     c->setMinimized(false);
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 0);
     }
 }
 
 void ScriptedEffectsTest::testScreenEdge()
 {
     // this test checks registerScreenEdge functions
     auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effect->load("screenEdgeTest"));
     effect->borderActivated(KWin::ElectricTopRight);
     QCOMPARE(effectOutputSpy.count(), 1);
 }
 
 void ScriptedEffectsTest::testScreenEdgeTouch()
 {
     // this test checks registerTouchScreenEdge functions
     auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effect->load("screenEdgeTouchTest"));
     auto actions = effect->findChildren<QAction*>(QString(), Qt::FindDirectChildrenOnly);
     actions[0]->trigger();
     QCOMPARE(effectOutputSpy.count(), 1);
 }
 
 void ScriptedEffectsTest::testFullScreenEffect_data()
 {
     QTest::addColumn<QString>("file");
 
     QTest::newRow("single") << "fullScreenEffectTest";
     QTest::newRow("multi")  << "fullScreenEffectTestMulti";
     QTest::newRow("global") << "fullScreenEffectTestGlobal";
 }
 
 void ScriptedEffectsTest::testFullScreenEffect()
 {
     QFETCH(QString, file);
 
     auto *effectMain = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
     QSignalSpy effectOutputSpy(effectMain, &ScriptedEffectWithDebugSpy::testOutput);
     QSignalSpy fullScreenEffectActiveSpy(effects, &EffectsHandler::hasActiveFullScreenEffectChanged);
     QSignalSpy isActiveFullScreenEffectSpy(effectMain, &ScriptedEffect::isActiveFullScreenEffectChanged);
 
     QVERIFY(effectMain->load(file));
 
     //load any random effect from another test to confirm fullscreen effect state is correctly
     //shown as being someone else
     auto effectOther = new ScriptedEffectWithDebugSpy();
     QVERIFY(effectOther->load("screenEdgeTouchTest"));
     QSignalSpy isActiveFullScreenEffectSpyOther(effectOther, &ScriptedEffect::isActiveFullScreenEffectChanged);
 
     using namespace KWayland::Client;
     auto *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
     QVERIFY(shellSurface);
     shellSurface->setTitle("Window 1");
     auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     QCOMPARE(effects->hasActiveFullScreenEffect(), false);
     QCOMPARE(effectMain->isActiveFullScreenEffect(), false);
 
     //trigger animation
     KWin::VirtualDesktopManager::self()->setCurrent(2);
 
     QCOMPARE(effects->activeFullScreenEffect(), effectMain);
     QCOMPARE(effects->hasActiveFullScreenEffect(), true);
     QCOMPARE(fullScreenEffectActiveSpy.count(), 1);
 
     QCOMPARE(effectMain->isActiveFullScreenEffect(), true);
     QCOMPARE(isActiveFullScreenEffectSpy.count(), 1);
 
     QCOMPARE(effectOther->isActiveFullScreenEffect(), false);
     QCOMPARE(isActiveFullScreenEffectSpyOther.count(), 0);
 
     //after 500ms trigger another full screen animation
     QTest::qWait(500);
     KWin::VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(effects->activeFullScreenEffect(), effectMain);
 
     //after 1000ms (+a safety margin for time based tests) we should still be the active full screen effect
     //despite first animation expiring
     QTest::qWait(500+100);
     QCOMPARE(effects->activeFullScreenEffect(), effectMain);
 
     //after 1500ms (+a safetey margin) we should have no full screen effect
     QTest::qWait(500+100);
     QCOMPARE(effects->activeFullScreenEffect(), nullptr);
 }
 
 void ScriptedEffectsTest::testKeepAlive_data()
 {
     QTest::addColumn<QString>("file");
     QTest::addColumn<bool>("keepAlive");
 
     QTest::newRow("keep")        << "keepAliveTest"         << true;
     QTest::newRow("don't keep")  << "keepAliveTestDontKeep" << false;
 }
 
 void ScriptedEffectsTest::testKeepAlive()
 {
     // this test checks whether closed windows are kept alive
     // when keepAlive property is set to true(false)
 
     QFETCH(QString, file);
     QFETCH(bool, keepAlive);
 
     auto *effect = new ScriptedEffectWithDebugSpy;
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effectOutputSpy.isValid());
     QVERIFY(effect->load(file));
 
     // create a window
     using namespace KWayland::Client;
     auto *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
     QVERIFY(shellSurface);
     auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // no active animations at the beginning
     QCOMPARE(effect->state().count(), 0);
 
     // trigger windowClosed signal
     surface->deleteLater();
     QVERIFY(effectOutputSpy.count() == 1 || effectOutputSpy.wait());
 
     if (keepAlive) {
         QCOMPARE(effect->state().count(), 1);
 
         QTest::qWait(500);
         QCOMPARE(effect->state().count(), 1);
 
         QTest::qWait(500 + 100); // 100ms is extra safety margin
         QCOMPARE(effect->state().count(), 0);
     } else {
         // the test effect doesn't keep the window alive, so it should be
         // removed immediately
         QSignalSpy deletedRemovedSpy(workspace(), &Workspace::deletedRemoved);
         QVERIFY(deletedRemovedSpy.isValid());
         QVERIFY(deletedRemovedSpy.count() == 1 || deletedRemovedSpy.wait(100)); // 100ms is less than duration of the animation
         QCOMPARE(effect->state().count(), 0);
     }
 }
 
 void ScriptedEffectsTest::testGrab()
 {
     // this test verifies that scripted effects can grab windows that are
     // not already grabbed
 
     // load the test effect
     auto effect = new ScriptedEffectWithDebugSpy;
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effectOutputSpy.isValid());
     QVERIFY(effect->load(QStringLiteral("grabTest")));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // the test effect should grab the test client successfully
     QCOMPARE(effectOutputSpy.count(), 1);
     QCOMPARE(effectOutputSpy.first().first(), QStringLiteral("ok"));
     QCOMPARE(c->effectWindow()->data(WindowAddedGrabRole).value<void *>(), effect);
 }
 
 void ScriptedEffectsTest::testGrabAlreadyGrabbedWindow()
 {
     // this test verifies that scripted effects cannot grab already grabbed
     // windows (unless force is set to true of course)
 
     // load effect that will hold the window grab
     auto owner = new ScriptedEffectWithDebugSpy;
     QSignalSpy ownerOutputSpy(owner, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(ownerOutputSpy.isValid());
     QVERIFY(owner->load(QStringLiteral("grabAlreadyGrabbedWindowTest_owner")));
 
     // load effect that will try to grab already grabbed window
     auto grabber = new ScriptedEffectWithDebugSpy;
     QSignalSpy grabberOutputSpy(grabber, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(grabberOutputSpy.isValid());
     QVERIFY(grabber->load(QStringLiteral("grabAlreadyGrabbedWindowTest_grabber")));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // effect that initially held the grab should still hold the grab
     QCOMPARE(ownerOutputSpy.count(), 1);
     QCOMPARE(ownerOutputSpy.first().first(), QStringLiteral("ok"));
     QCOMPARE(c->effectWindow()->data(WindowAddedGrabRole).value<void *>(), owner);
 
     // effect that tried to grab already grabbed window should fail miserably
     QCOMPARE(grabberOutputSpy.count(), 1);
     QCOMPARE(grabberOutputSpy.first().first(), QStringLiteral("fail"));
 }
 
 void ScriptedEffectsTest::testGrabAlreadyGrabbedWindowForced()
 {
     // this test verifies that scripted effects can steal window grabs when
     // they forcefully try to grab windows
 
     // load effect that initially will be holding the window grab
     auto owner = new ScriptedEffectWithDebugSpy;
     QSignalSpy ownerOutputSpy(owner, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(ownerOutputSpy.isValid());
     QVERIFY(owner->load(QStringLiteral("grabAlreadyGrabbedWindowForcedTest_owner")));
 
     // load effect that will try to steal the window grab
     auto thief = new ScriptedEffectWithDebugSpy;
     QSignalSpy thiefOutputSpy(thief, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(thiefOutputSpy.isValid());
     QVERIFY(thief->load(QStringLiteral("grabAlreadyGrabbedWindowForcedTest_thief")));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // verify that the owner in fact held the grab
     QCOMPARE(ownerOutputSpy.count(), 1);
     QCOMPARE(ownerOutputSpy.first().first(), QStringLiteral("ok"));
 
     // effect that grabbed the test client forcefully should now hold the grab
     QCOMPARE(thiefOutputSpy.count(), 1);
     QCOMPARE(thiefOutputSpy.first().first(), QStringLiteral("ok"));
     QCOMPARE(c->effectWindow()->data(WindowAddedGrabRole).value<void *>(), thief);
 }
 
 void ScriptedEffectsTest::testUngrab()
 {
     // this test verifies that scripted effects can ungrab windows that they
     // are previously grabbed
 
     // load the test effect
     auto effect = new ScriptedEffectWithDebugSpy;
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effectOutputSpy.isValid());
     QVERIFY(effect->load(QStringLiteral("ungrabTest")));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // the test effect should grab the test client successfully
     QCOMPARE(effectOutputSpy.count(), 1);
     QCOMPARE(effectOutputSpy.first().first(), QStringLiteral("ok"));
     QCOMPARE(c->effectWindow()->data(WindowAddedGrabRole).value<void *>(), effect);
 
     // when the test effect sees that a window was minimized, it will try to ungrab it
     effectOutputSpy.clear();
     c->setMinimized(true);
 
     QCOMPARE(effectOutputSpy.count(), 1);
     QCOMPARE(effectOutputSpy.first().first(), QStringLiteral("ok"));
     QCOMPARE(c->effectWindow()->data(WindowAddedGrabRole).value<void *>(), nullptr);
 }
 
 void ScriptedEffectsTest::testRedirect_data()
 {
     QTest::addColumn<QString>("file");
     QTest::addColumn<bool>("shouldTerminate");
     QTest::newRow("animate/DontTerminateAtSource") << "redirectAnimateDontTerminateTest" << false;
     QTest::newRow("animate/TerminateAtSource")     << "redirectAnimateTerminateTest"     << true;
     QTest::newRow("set/DontTerminate")             << "redirectSetDontTerminateTest"     << false;
     QTest::newRow("set/Terminate")                 << "redirectSetTerminateTest"         << true;
 }
 
 void ScriptedEffectsTest::testRedirect()
 {
     // this test verifies that redirect() works
 
     // load the test effect
     auto effect = new ScriptedEffectWithDebugSpy;
     QFETCH(QString, file);
     QVERIFY(effect->load(file));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     auto around = [] (std::chrono::milliseconds elapsed,
                       std::chrono::milliseconds pivot,
                       std::chrono::milliseconds margin) {
         return qAbs(elapsed.count() - pivot.count()) < margin.count();
     };
 
     // initially, the test animation is at the source position
 
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QCOMPARE(animations[0].timeLine.direction(), TimeLine::Forward);
         QVERIFY(around(animations[0].timeLine.elapsed(), 0ms, 50ms));
     }
 
     // minimize the test client after 250ms, when the test effect sees that
     // a window was minimized, it will try to reverse animation for it
     QTest::qWait(250);
 
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effectOutputSpy.isValid());
 
     c->setMinimized(true);
 
     QCOMPARE(effectOutputSpy.count(), 1);
     QCOMPARE(effectOutputSpy.first().first(), QStringLiteral("ok"));
 
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QCOMPARE(animations[0].timeLine.direction(), TimeLine::Backward);
         QVERIFY(around(animations[0].timeLine.elapsed(), 1000ms - 250ms, 50ms));
     }
 
     // wait for the animation to reach the start position, 100ms is an extra
     // safety margin
     QTest::qWait(250 + 100);
 
     QFETCH(bool, shouldTerminate);
     if (shouldTerminate) {
         const auto state = effect->state();
         QCOMPARE(state.count(), 0);
     } else {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QCOMPARE(animations[0].timeLine.direction(), TimeLine::Backward);
         QCOMPARE(animations[0].timeLine.elapsed(), 1000ms);
         QCOMPARE(animations[0].timeLine.value(), 0.0);
     }
 }
 
 void ScriptedEffectsTest::testComplete()
 {
     // this test verifies that complete works
 
     // load the test effect
     auto effect = new ScriptedEffectWithDebugSpy;
     QVERIFY(effect->load(QStringLiteral("completeTest")));
 
     // create test client
     using namespace KWayland::Client;
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
-    XdgShellClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     auto around = [] (std::chrono::milliseconds elapsed,
                       std::chrono::milliseconds pivot,
                       std::chrono::milliseconds margin) {
         return qAbs(elapsed.count() - pivot.count()) < margin.count();
     };
 
     // initially, the test animation should be at the start position
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QVERIFY(around(animations[0].timeLine.elapsed(), 0ms, 50ms));
         QVERIFY(!animations[0].timeLine.done());
     }
 
     // wait for 250ms
     QTest::qWait(250);
 
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QVERIFY(around(animations[0].timeLine.elapsed(), 250ms, 50ms));
         QVERIFY(!animations[0].timeLine.done());
     }
 
     // minimize the test client, when the test effect sees that a window was
     // minimized, it will try to complete animation for it
     QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
     QVERIFY(effectOutputSpy.isValid());
 
     c->setMinimized(true);
 
     QCOMPARE(effectOutputSpy.count(), 1);
     QCOMPARE(effectOutputSpy.first().first(), QStringLiteral("ok"));
 
     {
         const auto state = effect->state();
         QCOMPARE(state.count(), 1);
         QCOMPARE(state.firstKey(), c->effectWindow());
         const QList<AniData> animations = state.first().first;
         QCOMPARE(animations.count(), 1);
         QCOMPARE(animations[0].timeLine.elapsed(), 1000ms);
         QVERIFY(animations[0].timeLine.done());
     }
 }
 
 WAYLANDTEST_MAIN(ScriptedEffectsTest)
 #include "scripted_effects_test.moc"
diff --git a/autotests/integration/effects/slidingpopups_test.cpp b/autotests/integration/effects/slidingpopups_test.cpp
index b5dcca4bd..ae438f3ce 100644
--- a/autotests/integration/effects/slidingpopups_test.cpp
+++ b/autotests/integration/effects/slidingpopups_test.cpp
@@ -1,380 +1,378 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "x11client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/slide.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_effects_slidingpopups-0");
 
 class SlidingPopupsTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testWithOtherEffect_data();
     void testWithOtherEffect();
     void testWithOtherEffectWayland_data();
     void testWithOtherEffectWayland();
 };
 
 void SlidingPopupsTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     KConfigGroup wobblyGroup = config->group("Effect-Wobbly");
     wobblyGroup.writeEntry(QStringLiteral("Settings"), QStringLiteral("Custom"));
     wobblyGroup.writeEntry(QStringLiteral("OpenEffect"), true);
     wobblyGroup.writeEntry(QStringLiteral("CloseEffect"), true);
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void SlidingPopupsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 }
 
 void SlidingPopupsTest::cleanup()
 {
     Test::destroyWaylandConnection();
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     while (!e->loadedEffects().isEmpty()) {
         const QString effect = e->loadedEffects().first();
         e->unloadEffect(effect);
         QVERIFY(!e->isEffectLoaded(effect));
     }
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 
 void SlidingPopupsTest::testWithOtherEffect_data()
 {
     QTest::addColumn<QStringList>("effectsToLoad");
 
     QTest::newRow("fade, slide") << QStringList{QStringLiteral("kwin4_effect_fade"), QStringLiteral("slidingpopups")};
     QTest::newRow("slide, fade") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("kwin4_effect_fade")};
     QTest::newRow("scale, slide") << QStringList{QStringLiteral("kwin4_effect_scale"), QStringLiteral("slidingpopups")};
     QTest::newRow("slide, scale") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("kwin4_effect_scale")};
 
     if (effects->compositingType() & KWin::OpenGLCompositing) {
         QTest::newRow("glide, slide") << QStringList{QStringLiteral("glide"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, glide") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("glide")};
         QTest::newRow("wobblywindows, slide") << QStringList{QStringLiteral("wobblywindows"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, wobblywindows") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("wobblywindows")};
         QTest::newRow("fallapart, slide") << QStringList{QStringLiteral("fallapart"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, fallapart") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("fallapart")};
     }
 }
 
 void SlidingPopupsTest::testWithOtherEffect()
 {
     // this test verifies that slidingpopups effect grabs the window added role
     // independently of the sequence how the effects are loaded.
     // see BUG 336866
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     // find the effectsloader
     auto effectloader = e->findChild<AbstractEffectLoader*>();
     QVERIFY(effectloader);
     QSignalSpy effectLoadedSpy(effectloader, &AbstractEffectLoader::effectLoaded);
     QVERIFY(effectLoadedSpy.isValid());
 
     Effect *slidingPoupus = nullptr;
     Effect *otherEffect = nullptr;
     QFETCH(QStringList, effectsToLoad);
     for (const QString &effectName : effectsToLoad) {
         QVERIFY(!e->isEffectLoaded(effectName));
         QVERIFY(e->loadEffect(effectName));
         QVERIFY(e->isEffectLoaded(effectName));
 
         QCOMPARE(effectLoadedSpy.count(), 1);
         Effect *effect = effectLoadedSpy.first().first().value<Effect*>();
         if (effectName == QStringLiteral("slidingpopups")) {
             slidingPoupus = effect;
         } else {
             otherEffect = effect;
         }
         effectLoadedSpy.clear();
     }
     QVERIFY(slidingPoupus);
     QVERIFY(otherEffect);
 
     QVERIFY(!slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
 
     // give the compositor some time to render
     QTest::qWait(50);
 
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::Properties(), NET::Properties2());
     winInfo.setWindowType(NET::Normal);
 
     // and get the slide atom
     const QByteArray effectAtomName = QByteArrayLiteral("_KDE_SLIDE");
     xcb_intern_atom_cookie_t atomCookie = xcb_intern_atom_unchecked(c.data(), false, effectAtomName.length(), effectAtomName.constData());
     const int size = 2;
     int32_t data[size];
     data[0] = 0;
     data[1] = 0;
     QScopedPointer<xcb_intern_atom_reply_t, QScopedPointerPodDeleter> atom(xcb_intern_atom_reply(c.data(), atomCookie, nullptr));
     QVERIFY(!atom.isNull());
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atom->atom, atom->atom, 32, size, data);
 
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isNormalWindow());
 
     // sliding popups should be active
     QVERIFY(windowAddedSpy.wait());
     QTRY_VERIFY(slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
 
     // wait till effect ends
     QTRY_VERIFY(!slidingPoupus->isActive());
     QTest::qWait(300);
     QVERIFY(!otherEffect->isActive());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
 
     QSignalSpy windowDeletedSpy(effects, &EffectsHandler::windowDeleted);
     QVERIFY(windowDeletedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 
     // again we should have the sliding popups active
     QVERIFY(slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
 
     QVERIFY(windowDeletedSpy.wait());
 
     QCOMPARE(windowDeletedSpy.count(), 1);
     QTRY_VERIFY(!slidingPoupus->isActive());
     QTest::qWait(300);
     QVERIFY(!otherEffect->isActive());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 void SlidingPopupsTest::testWithOtherEffectWayland_data()
 {
     QTest::addColumn<QStringList>("effectsToLoad");
 
     QTest::newRow("fade, slide") << QStringList{QStringLiteral("kwin4_effect_fade"), QStringLiteral("slidingpopups")};
     QTest::newRow("slide, fade") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("kwin4_effect_fade")};
     QTest::newRow("scale, slide") << QStringList{QStringLiteral("kwin4_effect_scale"), QStringLiteral("slidingpopups")};
     QTest::newRow("slide, scale") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("kwin4_effect_scale")};
 
     if (effects->compositingType() & KWin::OpenGLCompositing) {
         QTest::newRow("glide, slide") << QStringList{QStringLiteral("glide"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, glide") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("glide")};
         QTest::newRow("wobblywindows, slide") << QStringList{QStringLiteral("wobblywindows"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, wobblywindows") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("wobblywindows")};
         QTest::newRow("fallapart, slide") << QStringList{QStringLiteral("fallapart"), QStringLiteral("slidingpopups")};
         QTest::newRow("slide, fallapart") << QStringList{QStringLiteral("slidingpopups"), QStringLiteral("fallapart")};
     }
 }
 
 void SlidingPopupsTest::testWithOtherEffectWayland()
 {
     // this test verifies that slidingpopups effect grabs the window added role
     // independently of the sequence how the effects are loaded.
     // see BUG 336866
     // the test is like testWithOtherEffect, but simulates using a Wayland window
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     // find the effectsloader
     auto effectloader = e->findChild<AbstractEffectLoader*>();
     QVERIFY(effectloader);
     QSignalSpy effectLoadedSpy(effectloader, &AbstractEffectLoader::effectLoaded);
     QVERIFY(effectLoadedSpy.isValid());
 
     Effect *slidingPoupus = nullptr;
     Effect *otherEffect = nullptr;
     QFETCH(QStringList, effectsToLoad);
     for (const QString &effectName : effectsToLoad) {
         QVERIFY(!e->isEffectLoaded(effectName));
         QVERIFY(e->loadEffect(effectName));
         QVERIFY(e->isEffectLoaded(effectName));
 
         QCOMPARE(effectLoadedSpy.count(), 1);
         Effect *effect = effectLoadedSpy.first().first().value<Effect*>();
         if (effectName == QStringLiteral("slidingpopups")) {
             slidingPoupus = effect;
         } else {
             otherEffect = effect;
         }
         effectLoadedSpy.clear();
     }
     QVERIFY(slidingPoupus);
     QVERIFY(otherEffect);
 
     QVERIFY(!slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     using namespace KWayland::Client;
     // the test created the slide protocol, let's create a Registry and listen for it
     QScopedPointer<Registry> registry(new Registry);
     registry->create(Test::waylandConnection());
 
     QSignalSpy interfacesAnnouncedSpy(registry.data(), &Registry::interfacesAnnounced);
     QVERIFY(interfacesAnnouncedSpy.isValid());
     registry->setup();
     QVERIFY(interfacesAnnouncedSpy.wait());
     auto slideInterface = registry->interface(Registry::Interface::Slide);
     QVERIFY(slideInterface.name != 0);
     QScopedPointer<SlideManager> slideManager(registry->createSlideManager(slideInterface.name, slideInterface.version));
     QVERIFY(slideManager);
 
     // create Wayland window
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(surface);
     QScopedPointer<Slide> slide(slideManager->createSlide(surface.data()));
     slide->setLocation(Slide::Location::Left);
     slide->commit();
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(shellSurface);
     QCOMPARE(windowAddedSpy.count(), 0);
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(10, 20), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isNormalWindow());
 
     // sliding popups should be active
     QCOMPARE(windowAddedSpy.count(), 1);
     QTRY_VERIFY(slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
 
     // wait till effect ends
     QTRY_VERIFY(!slidingPoupus->isActive());
     QTest::qWait(300);
     QVERIFY(!otherEffect->isActive());
 
     // and destroy the window again
     shellSurface.reset();
     surface.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
 
     QSignalSpy windowDeletedSpy(effects, &EffectsHandler::windowDeleted);
     QVERIFY(windowDeletedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 
     // again we should have the sliding popups active
     QVERIFY(slidingPoupus->isActive());
     QVERIFY(!otherEffect->isActive());
 
     QVERIFY(windowDeletedSpy.wait());
 
     QCOMPARE(windowDeletedSpy.count(), 1);
     QTRY_VERIFY(!slidingPoupus->isActive());
     QTest::qWait(300);
     QVERIFY(!otherEffect->isActive());
 }
 
 WAYLANDTEST_MAIN(SlidingPopupsTest)
 #include "slidingpopups_test.moc"
diff --git a/autotests/integration/effects/toplevel_open_close_animation_test.cpp b/autotests/integration/effects/toplevel_open_close_animation_test.cpp
index cce83496e..429046e5b 100644
--- a/autotests/integration/effects/toplevel_open_close_animation_test.cpp
+++ b/autotests/integration/effects/toplevel_open_close_animation_test.cpp
@@ -1,224 +1,222 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include "effect_builtins.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_effects_toplevel_open_close_animation-0");
 
 class ToplevelOpenCloseAnimationTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testAnimateToplevels_data();
     void testAnimateToplevels();
     void testDontAnimatePopups_data();
     void testDontAnimatePopups();
 };
 
 void ToplevelOpenCloseAnimationTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::Deleted *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (const QString &name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void ToplevelOpenCloseAnimationTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void ToplevelOpenCloseAnimationTest::cleanup()
 {
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 
     Test::destroyWaylandConnection();
 }
 
 void ToplevelOpenCloseAnimationTest::testAnimateToplevels_data()
 {
     QTest::addColumn<QString>("effectName");
 
     QTest::newRow("Fade")   << QStringLiteral("kwin4_effect_fade");
     QTest::newRow("Glide")  << QStringLiteral("glide");
     QTest::newRow("Scale")  << QStringLiteral("kwin4_effect_scale");
 }
 
 void ToplevelOpenCloseAnimationTest::testAnimateToplevels()
 {
     // This test verifies that window open/close animation effects try to
     // animate the appearing and the disappearing of toplevel windows.
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Load effect that will be tested.
     QFETCH(QString, effectName);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 
     // Close the test client, the effect should start animating the disappearing
     // of the client.
-    QSignalSpy windowClosedSpy(client, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(client, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
     QVERIFY(effect->isActive());
 
     // Eventually, the animation will be complete.
     QTRY_VERIFY(!effect->isActive());
 }
 
 void ToplevelOpenCloseAnimationTest::testDontAnimatePopups_data()
 {
     QTest::addColumn<QString>("effectName");
 
     QTest::newRow("Fade")   << QStringLiteral("kwin4_effect_fade");
     QTest::newRow("Glide")  << QStringLiteral("glide");
     QTest::newRow("Scale")  << QStringLiteral("kwin4_effect_scale");
 }
 
 void ToplevelOpenCloseAnimationTest::testDontAnimatePopups()
 {
     // This test verifies that window open/close animation effects don't try
     // to animate popups(e.g. popup menus, tooltips, etc).
 
     // Make sure that we have the right effects ptr.
     auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
     QVERIFY(effectsImpl);
 
     // Create the main window.
     using namespace KWayland::Client;
     QScopedPointer<Surface> mainWindowSurface(Test::createSurface());
     QVERIFY(!mainWindowSurface.isNull());
     QScopedPointer<XdgShellSurface> mainWindowShellSurface(Test::createXdgShellStableSurface(mainWindowSurface.data()));
     QVERIFY(!mainWindowShellSurface.isNull());
-    XdgShellClient *mainWindow = Test::renderAndWaitForShown(mainWindowSurface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *mainWindow = Test::renderAndWaitForShown(mainWindowSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(mainWindow);
 
     // Load effect that will be tested.
     QFETCH(QString, effectName);
     QVERIFY(effectsImpl->loadEffect(effectName));
     QCOMPARE(effectsImpl->loadedEffects().count(), 1);
     QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
     Effect *effect = effectsImpl->findEffect(effectName);
     QVERIFY(effect);
     QVERIFY(!effect->isActive());
 
     // Create a popup, it should not be animated.
     QScopedPointer<Surface> popupSurface(Test::createSurface());
     QVERIFY(!popupSurface.isNull());
     XdgPositioner positioner(QSize(20, 20), QRect(0, 0, 10, 10));
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::LeftEdge);
     QScopedPointer<XdgShellPopup> popupShellSurface(Test::createXdgShellStablePopup(popupSurface.data(), mainWindowShellSurface.data(), positioner));
     QVERIFY(!popupShellSurface.isNull());
-    XdgShellClient *popup = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::red);
+    AbstractClient *popup = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::red);
     QVERIFY(popup);
     QVERIFY(popup->isPopupWindow());
     QCOMPARE(popup->transientFor(), mainWindow);
     QVERIFY(!effect->isActive());
 
     // Destroy the popup, it should not be animated.
-    QSignalSpy popupClosedSpy(popup, &XdgShellClient::windowClosed);
+    QSignalSpy popupClosedSpy(popup, &AbstractClient::windowClosed);
     QVERIFY(popupClosedSpy.isValid());
     popupShellSurface.reset();
     popupSurface.reset();
     QVERIFY(popupClosedSpy.wait());
     QVERIFY(!effect->isActive());
 
     // Destroy the main window.
     mainWindowSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(mainWindow));
 }
 
 WAYLANDTEST_MAIN(ToplevelOpenCloseAnimationTest)
 #include "toplevel_open_close_animation_test.moc"
diff --git a/autotests/integration/effects/translucency_test.cpp b/autotests/integration/effects/translucency_test.cpp
index 4e436d92e..3cff53ccf 100644
--- a/autotests/integration/effects/translucency_test.cpp
+++ b/autotests/integration/effects/translucency_test.cpp
@@ -1,250 +1,248 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "x11client.h"
 #include "composite.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_effects_translucency-0");
 
 class TranslucencyTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMoveAfterDesktopChange();
     void testDialogClose();
 
 private:
     Effect *m_translucencyEffect = nullptr;
 };
 
 void TranslucencyTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     config->group("Outline").writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
     config->group("Effect-kwin4_effect_translucency").writeEntry(QStringLiteral("Dialogs"), 90);
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 }
 
 void TranslucencyTest::init()
 {
     // load the translucency effect
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     // find the effectsloader
     auto effectloader = e->findChild<AbstractEffectLoader*>();
     QVERIFY(effectloader);
     QSignalSpy effectLoadedSpy(effectloader, &AbstractEffectLoader::effectLoaded);
     QVERIFY(effectLoadedSpy.isValid());
 
     QVERIFY(!e->isEffectLoaded(QStringLiteral("kwin4_effect_translucency")));
     QVERIFY(e->loadEffect(QStringLiteral("kwin4_effect_translucency")));
     QVERIFY(e->isEffectLoaded(QStringLiteral("kwin4_effect_translucency")));
 
     QCOMPARE(effectLoadedSpy.count(), 1);
     m_translucencyEffect = effectLoadedSpy.first().first().value<Effect*>();
     QVERIFY(m_translucencyEffect);
 }
 
 void TranslucencyTest::cleanup()
 {
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     if (e->isEffectLoaded(QStringLiteral("kwin4_effect_translucency"))) {
         e->unloadEffect(QStringLiteral("kwin4_effect_translucency"));
     }
     QVERIFY(!e->isEffectLoaded(QStringLiteral("kwin4_effect_translucency")));
     m_translucencyEffect = nullptr;
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void TranslucencyTest::testMoveAfterDesktopChange()
 {
     // test tries to simulate the condition of bug 366081
     QVERIFY(!m_translucencyEffect->isActive());
 
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
 
     QVERIFY(windowAddedSpy.wait());
     QVERIFY(!m_translucencyEffect->isActive());
     // let's send the window to desktop 2
     effects->setNumberOfDesktops(2);
     QCOMPARE(effects->numberOfDesktops(), 2);
     workspace()->sendClientToDesktop(client, 2, false);
     effects->setCurrentDesktop(2);
     QVERIFY(!m_translucencyEffect->isActive());
     KWin::Cursor::setPos(client->frameGeometry().center());
     workspace()->performWindowOperation(client, Options::MoveOp);
     QVERIFY(m_translucencyEffect->isActive());
     QTest::qWait(200);
     QVERIFY(m_translucencyEffect->isActive());
     // now end move resize
     client->endMoveResize();
     QVERIFY(m_translucencyEffect->isActive());
     QTest::qWait(500);
     QTRY_VERIFY(!m_translucencyEffect->isActive());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 void TranslucencyTest::testDialogClose()
 {
     // this test simulates the condition of BUG 342716
     // with translucency settings for window type dialog the effect never ends when the window gets destroyed
     QVERIFY(!m_translucencyEffect->isActive());
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::Properties(), NET::Properties2());
     winInfo.setWindowType(NET::Dialog);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QVERIFY(client->isDialog());
 
     QVERIFY(windowAddedSpy.wait());
     QTRY_VERIFY(m_translucencyEffect->isActive());
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
 
     QSignalSpy windowDeletedSpy(effects, &EffectsHandler::windowDeleted);
     QVERIFY(windowDeletedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     if (windowDeletedSpy.isEmpty()) {
         QVERIFY(windowDeletedSpy.wait());
     }
     QCOMPARE(windowDeletedSpy.count(), 1);
     QTRY_VERIFY(!m_translucencyEffect->isActive());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 WAYLANDTEST_MAIN(TranslucencyTest)
 #include "translucency_test.moc"
diff --git a/autotests/integration/effects/windowgeometry_test.cpp b/autotests/integration/effects/windowgeometry_test.cpp
index e72c1c7d0..1e7d17230 100644
--- a/autotests/integration/effects/windowgeometry_test.cpp
+++ b/autotests/integration/effects/windowgeometry_test.cpp
@@ -1,98 +1,97 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "composite.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Client/surface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 static const QString s_socketName = QStringLiteral("wayland_test_effects_windowgeometry-0");
 
 class WindowGeometryTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testStartup();
 };
 
 void WindowGeometryTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
     plugins.writeEntry(BuiltInEffects::nameForEffect(BuiltInEffect::WindowGeometry) + QStringLiteral("Enabled"), true);
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 }
 
 void WindowGeometryTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void WindowGeometryTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void WindowGeometryTest::testStartup()
 {
     // just a test to load the effect to verify it doesn't crash
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     QVERIFY(e->isEffectLoaded(BuiltInEffects::nameForEffect(BuiltInEffect::WindowGeometry)));
 }
 
 WAYLANDTEST_MAIN(WindowGeometryTest)
 #include "windowgeometry_test.moc"
diff --git a/autotests/integration/effects/wobbly_shade_test.cpp b/autotests/integration/effects/wobbly_shade_test.cpp
index dcbcbd62f..60d4e0dca 100644
--- a/autotests/integration/effects/wobbly_shade_test.cpp
+++ b/autotests/integration/effects/wobbly_shade_test.cpp
@@ -1,199 +1,197 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Martin Flöser <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 "kwin_wayland_test.h"
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/slide.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_effects_wobbly_shade-0");
 
 class WobblyWindowsShadeTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testShadeMove();
 };
 
 void WobblyWindowsShadeTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Effect*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void WobblyWindowsShadeTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 }
 
 void WobblyWindowsShadeTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     auto effectsImpl = static_cast<EffectsHandlerImpl *>(effects);
     effectsImpl->unloadAllEffects();
     QVERIFY(effectsImpl->loadedEffects().isEmpty());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void WobblyWindowsShadeTest::testShadeMove()
 {
     // this test simulates the condition from BUG 390953
     EffectsHandlerImpl *e = static_cast<EffectsHandlerImpl*>(effects);
     QVERIFY(e->loadEffect(BuiltInEffects::nameForEffect(BuiltInEffect::WobblyWindows)));
     QVERIFY(e->isEffectLoaded(BuiltInEffects::nameForEffect(BuiltInEffect::WobblyWindows)));
 
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QVERIFY(client->isShadeable());
     QVERIFY(!client->isShade());
     QVERIFY(client->isActive());
 
     QSignalSpy windowShownSpy(client, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     QVERIFY(windowShownSpy.wait());
 
     // now shade the window
     workspace()->slotWindowShade();
     QVERIFY(client->isShade());
 
     QSignalSpy windowStartUserMovedResizedSpy(e, &EffectsHandler::windowStartUserMovedResized);
     QVERIFY(windowStartUserMovedResizedSpy.isValid());
 
     // begin move
     QVERIFY(workspace()->moveResizeClient() == nullptr);
     QCOMPARE(client->isMove(), false);
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(client->isMove(), true);
     QCOMPARE(windowStartUserMovedResizedSpy.count(), 1);
 
     // wait for frame rendered
     QTest::qWait(100);
 
     // send some key events, not going through input redirection
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
 
     // wait for frame rendered
     QTest::qWait(100);
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
 
     // wait for frame rendered
     QTest::qWait(100);
 
     client->keyPressEvent(Qt::Key_Down | Qt::ALT);
     client->updateMoveResize(KWin::Cursor::pos());
 
     // wait for frame rendered
     QTest::qWait(100);
 
     // let's end
     client->keyPressEvent(Qt::Key_Enter);
 
     // wait for frame rendered
     QTest::qWait(100);
 }
 
 WAYLANDTEST_MAIN(WobblyWindowsShadeTest)
 #include "wobbly_shade_test.moc"
diff --git a/autotests/integration/generic_scene_opengl_test.cpp b/autotests/integration/generic_scene_opengl_test.cpp
index f7bbd71c2..14f1c9271 100644
--- a/autotests/integration/generic_scene_opengl_test.cpp
+++ b/autotests/integration/generic_scene_opengl_test.cpp
@@ -1,120 +1,119 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "generic_scene_opengl_test.h"
+#include "abstract_client.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "platform.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "effect_builtins.h"
 
 #include <KConfigGroup>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_opengl-0");
 
 GenericSceneOpenGLTest::GenericSceneOpenGLTest(const QByteArray &envVariable)
     : QObject()
     , m_envVariable(envVariable)
 {
 }
 
 GenericSceneOpenGLTest::~GenericSceneOpenGLTest()
 {
 }
 
 void GenericSceneOpenGLTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void GenericSceneOpenGLTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", m_envVariable);
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
     QCOMPARE(kwinApp()->platform()->selectedCompositor(), KWin::OpenGLCompositing);
 }
 
 void GenericSceneOpenGLTest::testRestart_data()
 {
     QTest::addColumn<bool>("core");
 
     QTest::newRow("GLCore") << true;
     QTest::newRow("Legacy") << false;
 }
 
 void GenericSceneOpenGLTest::testRestart()
 {
     // simple restart of the OpenGL compositor without any windows being shown
 
     // setup opengl compositing options
     auto compositingGroup = kwinApp()->config()->group("Compositing");
     QFETCH(bool, core);
     compositingGroup.writeEntry("GLCore", core);
     compositingGroup.sync();
 
     QSignalSpy sceneCreatedSpy(KWin::Compositor::self(), &Compositor::sceneCreated);
     QVERIFY(sceneCreatedSpy.isValid());
     KWin::Compositor::self()->reinitialize();
     if (sceneCreatedSpy.isEmpty()) {
         QVERIFY(sceneCreatedSpy.wait());
     }
     QCOMPARE(sceneCreatedSpy.count(), 1);
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
     QCOMPARE(kwinApp()->platform()->selectedCompositor(), KWin::OpenGLCompositing);
 
     // trigger a repaint
     KWin::Compositor::self()->addRepaintFull();
     // and wait 100 msec to ensure it's rendered
     // TODO: introduce frameRendered signal in SceneOpenGL
     QTest::qWait(100);
 }
diff --git a/autotests/integration/globalshortcuts_test.cpp b/autotests/integration/globalshortcuts_test.cpp
index 5c3b9c226..9403ac7bf 100644
--- a/autotests/integration/globalshortcuts_test.cpp
+++ b/autotests/integration/globalshortcuts_test.cpp
@@ -1,383 +1,381 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "input.h"
 #include "internal_client.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "useractions.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/seat_interface.h>
 
 #include <KGlobalAccel>
 #include <linux/input.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_globalshortcuts-0");
 
 class GlobalShortcutsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testConsumedShift();
     void testRepeatedTrigger();
     void testUserActionsMenu();
     void testMetaShiftW();
     void testComponseKey();
     void testX11ClientShortcut();
     void testWaylandClientShortcut();
     void testSetupWindowShortcut();
 };
 
 void GlobalShortcutsTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void GlobalShortcutsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(640, 512));
 }
 
 void GlobalShortcutsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void GlobalShortcutsTest::testConsumedShift()
 {
     // this test verifies that a shortcut with a consumed shift modifier triggers
     // create the action
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testRepeatedTrigger()
 {
     // this test verifies that holding a key, triggers repeated global shortcut
     // in addition pressing another key should stop triggering the shortcut
 
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // we need to configure the key repeat first. It is only enabled on libinput
     waylandServer()->seat()->setKeyRepeatInfo(25, 300);
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_WAKEUP, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     // and should repeat
     QVERIFY(triggeredSpy.wait());
     QVERIFY(triggeredSpy.wait());
     // now release the key
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_WAKEUP, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testUserActionsMenu()
 {
     // this test tries to trigger the user actions menu with Alt+F3
     // the problem here is that pressing F3 consumes modifiers as it's part of the
     // Ctrl+alt+F3 keysym for vt switching. xkbcommon considers all modifiers as consumed
     // which a transformation to any keysym would cause
     // for more information see:
     // https://bugs.freedesktop.org/show_bug.cgi?id=92818
     // https://github.com/xkbcommon/libxkbcommon/issues/17
 
     // first create a window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
 
     quint32 timestamp = 0;
     QVERIFY(!workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_F3, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_F3, timestamp++);
     QTRY_VERIFY(workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 }
 
 void GlobalShortcutsTest::testMetaShiftW()
 {
     // BUG 370341
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-meta-shift-w"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::META + Qt::SHIFT + Qt::Key_W}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::META + Qt::SHIFT + Qt::Key_W, action.data());
 
     // press meta+shift+w
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier | Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_W, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_W, timestamp++);
 
     // release meta+shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 }
 
 void GlobalShortcutsTest::testComponseKey()
 {
     // BUG 390110
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-accent"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::UNICODE_ACCEL}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::UNICODE_ACCEL, action.data());
 
     // press & release `
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_RESERVED, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RESERVED, timestamp++);
 
     QTRY_COMPARE(triggeredSpy.count(), 0);
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void GlobalShortcutsTest::testX11ClientShortcut()
 {
     // create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 10, 20);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     // it's delayed
     QCoreApplication::processEvents();
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void GlobalShortcutsTest::testWaylandClientShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QVERIFY(workspace()->shortcutAvailable(seq));
 }
 
 void GlobalShortcutsTest::testSetupWindowShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
 
     QSignalSpy shortcutDialogAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(shortcutDialogAddedSpy.isValid());
     workspace()->slotSetupWindowShortcut();
     QTRY_COMPARE(shortcutDialogAddedSpy.count(), 1);
     auto dialog = shortcutDialogAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(dialog);
     QVERIFY(dialog->isInternal());
     auto sequenceEdit = workspace()->shortcutDialog()->findChild<QKeySequenceEdit*>();
     QVERIFY(sequenceEdit);
 
     // the QKeySequenceEdit field does not get focus, we need to pass it focus manually
     QEXPECT_FAIL("", "Edit does not have focus", Continue);
     QVERIFY(sequenceEdit->hasFocus());
     sequenceEdit->setFocus();
     QTRY_VERIFY(sequenceEdit->hasFocus());
 
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // the sequence gets accepted after one second, so wait a bit longer
     QTest::qWait(2000);
     // now send in enter
     kwinApp()->platform()->keyboardKeyPressed(KEY_ENTER, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ENTER, timestamp++);
     QTRY_COMPARE(client->shortcut(), QKeySequence(Qt::META + Qt::SHIFT + Qt::Key_Y));
 }
 
 WAYLANDTEST_MAIN(GlobalShortcutsTest)
 #include "globalshortcuts_test.moc"
diff --git a/autotests/integration/idle_inhibition_test.cpp b/autotests/integration/idle_inhibition_test.cpp
index e3ddd1780..12b952834 100644
--- a/autotests/integration/idle_inhibition_test.cpp
+++ b/autotests/integration/idle_inhibition_test.cpp
@@ -1,361 +1,360 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/idleinhibit.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/idle_interface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 using KWayland::Server::IdleInterface;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_idle_inhbition_test-0");
 
 class TestIdleInhibition : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testInhibit_data();
     void testInhibit();
     void testDontInhibitWhenNotOnCurrentDesktop();
     void testDontInhibitWhenMinimized();
     void testDontInhibitWhenUnmapped();
     void testDontInhibitWhenLeftCurrentDesktop();
 };
 
 void TestIdleInhibition::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void TestIdleInhibition::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::IdleInhibition));
 
 }
 
 void TestIdleInhibition::cleanup()
 {
     Test::destroyWaylandConnection();
 
     VirtualDesktopManager::self()->setCount(1);
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
 }
 
 void TestIdleInhibition::testInhibit_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase")  << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestIdleInhibition::testInhibit()
 {
     auto idle = waylandServer()->display()->findChild<IdleInterface*>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // now create window
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     // now create inhibition on window
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // render the client
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // this should inhibit our server object
     QVERIFY(idle->isInhibited());
 
     // deleting the object should uninhibit again
     inhibitor.reset();
     QVERIFY(inhibitedSpy.wait());
     QVERIFY(!idle->isInhibited());
 
     // inhibit again and destroy window
     Test::waylandIdleInhibitManager()->createInhibitor(surface.data(), surface.data());
     QVERIFY(inhibitedSpy.wait());
     QVERIFY(idle->isInhibited());
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenNotOnCurrentDesktop()
 {
     // This test verifies that the idle inhibitor object is not honored when
     // the associated surface is not on the current virtual desktop.
 
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // The test client should be only on the first virtual desktop.
     QCOMPARE(c->desktops().count(), 1);
     QCOMPARE(c->desktops().first(), VirtualDesktopManager::self()->desktops().first());
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Switch to the second virtual desktop.
     VirtualDesktopManager::self()->setCurrent(2);
 
     // The surface is no longer visible, so the compositor don't have to honor the
     // idle inhibitor object.
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Switch back to the first virtual desktop.
     VirtualDesktopManager::self()->setCurrent(1);
 
     // The test client became visible again, so the compositor has to honor the idle
     // inhibitor object back again.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenMinimized()
 {
     // This test verifies that the idle inhibitor object is not honored when the
     // associated surface is minimized.
 
      // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Minimize the client, the idle inhibitor object should not be honored.
     c->minimize();
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Unminimize the client, the idle inhibitor object should be honored back again.
     c->unminimize();
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenUnmapped()
 {
     // This test verifies that the idle inhibitor object is not honored by KWin
     // when the associated client is unmapped.
 
      // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Unmap the client.
-    QSignalSpy hiddenSpy(c, &XdgShellClient::windowHidden);
+    QSignalSpy hiddenSpy(c, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
 
     // The surface is no longer visible, so the compositor don't have to honor the
     // idle inhibitor object.
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Map the client.
-    QSignalSpy windowShownSpy(c, &XdgShellClient::windowShown);
+    QSignalSpy windowShownSpy(c, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(windowShownSpy.wait());
 
     // The test client became visible again, so the compositor has to honor the idle
     // inhibitor object back again.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenLeftCurrentDesktop()
 {
     // This test verifies that the idle inhibitor object is not honored by KWin
     // when the associated surface leaves the current virtual desktop.
 
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // The test client should be only on the first virtual desktop.
     QCOMPARE(c->desktops().count(), 1);
     QCOMPARE(c->desktops().first(), VirtualDesktopManager::self()->desktops().first());
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Let the client enter the second virtual desktop.
     c->enterDesktop(VirtualDesktopManager::self()->desktops().at(1));
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // If the client leaves the first virtual desktop, then the associated idle
     // inhibitor object should not be honored.
     c->leaveDesktop(VirtualDesktopManager::self()->desktops().at(0));
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // If the client enters the first desktop, then the associated idle inhibitor
     // object should be honored back again.
     c->enterDesktop(VirtualDesktopManager::self()->desktops().at(0));
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 WAYLANDTEST_MAIN(TestIdleInhibition)
 #include "idle_inhibition_test.moc"
diff --git a/autotests/integration/input_stacking_order.cpp b/autotests/integration/input_stacking_order.cpp
index be59d873e..45730372a 100644
--- a/autotests/integration/input_stacking_order.cpp
+++ b/autotests/integration/input_stacking_order.cpp
@@ -1,189 +1,187 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 #include <KWayland/Server/seat_interface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_input_stacking_order-0");
 
 class InputStackingOrderTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testPointerFocusUpdatesOnStackingOrderChange_data();
     void testPointerFocusUpdatesOnStackingOrderChange();
 
 private:
     void render(KWayland::Client::Surface *surface);
 };
 
 void InputStackingOrderTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void InputStackingOrderTest::init()
 {
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void InputStackingOrderTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void InputStackingOrderTest::render(KWayland::Client::Surface *surface)
 {
     Test::render(surface, QSize(100, 50), Qt::blue);
     Test::flushWaylandConnection();
 }
 
 void InputStackingOrderTest::testPointerFocusUpdatesOnStackingOrderChange_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void InputStackingOrderTest::testPointerFocusUpdatesOnStackingOrderChange()
 {
     // this test creates two windows which overlap
     // the pointer is in the overlapping area which means the top most window has focus
     // as soon as the top most window gets lowered the window should lose focus and the
     // other window should gain focus without a mouse event in between
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and leave signals
     auto pointer = Test::waylandSeat()->createPointer(Test::waylandSeat());
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     // now create the two windows and make them overlap
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface1);
     QFETCH(Test::XdgShellSurfaceType, type);
     XdgShellSurface *shellSurface1 = Test::createXdgShellSurface(type, surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
 
     Surface *surface2 = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellSurface(type, surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2);
     QVERIFY(clientAddedSpy.wait());
 
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
 
     // now make windows overlap
     window2->move(window1->pos());
     QCOMPARE(window1->frameGeometry(), window2->frameGeometry());
 
     // enter
     kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     // window 2 should have focus
     QCOMPARE(pointer->enteredSurface(), surface2);
     // also on the server
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window2->surface());
 
     // raise window 1 above window 2
     QVERIFY(leftSpy.isEmpty());
     workspace()->raiseClient(window1);
     // should send leave to window2
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     // and an enter to window1
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(pointer->enteredSurface(), surface1);
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window1->surface());
 
     // let's destroy window1, that should pass focus to window2 again
     QSignalSpy windowClosedSpy(window1, &Toplevel::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     surface1->deleteLater();
     QVERIFY(windowClosedSpy.wait());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 3);
     QCOMPARE(pointer->enteredSurface(), surface2);
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window2->surface());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::InputStackingOrderTest)
 #include "input_stacking_order.moc"
diff --git a/autotests/integration/internal_window.cpp b/autotests/integration/internal_window.cpp
index 7b6897008..ac2fcab90 100644
--- a/autotests/integration/internal_window.cpp
+++ b/autotests/integration/internal_window.cpp
@@ -1,801 +1,799 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "cursor.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <QPainter>
 #include <QRasterWindow>
 
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/seat.h>
 #include <KWindowSystem>
 
 #include <KWayland/Server/surface_interface.h>
 
 #include <linux/input.h>
 
 using namespace KWayland::Client;
 
 Q_DECLARE_METATYPE(NET::WindowType);
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_internal_window-0");
 
 class InternalWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testEnterLeave();
     void testPointerPressRelease();
     void testPointerAxis();
     void testKeyboard_data();
     void testKeyboard();
     void testKeyboardShowWithoutActivating();
     void testKeyboardTriggersLeave();
     void testTouch();
     void testOpacity();
     void testMove();
     void testSkipCloseAnimation_data();
     void testSkipCloseAnimation();
     void testModifierClickUnrestrictedMove();
     void testModifierScroll();
     void testPopup();
     void testScale();
     void testWindowType_data();
     void testWindowType();
     void testChangeWindowType_data();
     void testChangeWindowType();
     void testEffectWindow();
 };
 
 class HelperWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     HelperWindow();
     ~HelperWindow() override;
 
     QPoint latestGlobalMousePos() const {
         return m_latestGlobalMousePos;
     }
     Qt::MouseButtons pressedButtons() const {
         return m_pressedButtons;
     }
 
 Q_SIGNALS:
     void entered();
     void left();
     void mouseMoved(const QPoint &global);
     void mousePressed();
     void mouseReleased();
     void wheel();
     void keyPressed();
     void keyReleased();
 
 protected:
     void paintEvent(QPaintEvent *event) override;
     bool event(QEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
     void mousePressEvent(QMouseEvent *event) override;
     void mouseReleaseEvent(QMouseEvent *event) override;
     void wheelEvent(QWheelEvent *event) override;
     void keyPressEvent(QKeyEvent *event) override;
     void keyReleaseEvent(QKeyEvent *event) override;
 
 private:
     QPoint m_latestGlobalMousePos;
     Qt::MouseButtons m_pressedButtons = Qt::MouseButtons();
 };
 
 HelperWindow::HelperWindow()
     : QRasterWindow(nullptr)
 {
     setFlags(Qt::FramelessWindowHint);
 }
 
 HelperWindow::~HelperWindow() = default;
 
 void HelperWindow::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event)
     QPainter p(this);
     p.fillRect(0, 0, width(), height(), Qt::red);
 }
 
 bool HelperWindow::event(QEvent *event)
 {
     if (event->type() == QEvent::Enter) {
         emit entered();
     }
     if (event->type() == QEvent::Leave) {
         emit left();
     }
     return QRasterWindow::event(event);
 }
 
 void HelperWindow::mouseMoveEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     emit mouseMoved(event->globalPos());
 }
 
 void HelperWindow::mousePressEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     m_pressedButtons = event->buttons();
     emit mousePressed();
 }
 
 void HelperWindow::mouseReleaseEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     m_pressedButtons = event->buttons();
     emit mouseReleased();
 }
 
 void HelperWindow::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     emit wheel();
 }
 
 void HelperWindow::keyPressEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     emit keyPressed();
 }
 
 void HelperWindow::keyReleaseEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     emit keyReleased();
 }
 
 void InternalWindowTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void InternalWindowTest::init()
 {
     Cursor::setPos(QPoint(1280, 512));
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandKeyboard());
 }
 
 void InternalWindowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 }
 
 void InternalWindowTest::testEnterLeave()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     QVERIFY(!workspace()->findInternal(nullptr));
     QVERIFY(!workspace()->findInternal(&win));
     win.setGeometry(0, 0, 100, 100);
     win.show();
 
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     QVERIFY(!workspace()->activeClient());
     InternalClient *c = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(c);
     QVERIFY(c->isInternal());
     QVERIFY(!c->isDecorated());
     QCOMPARE(workspace()->findInternal(&win), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 100));
     QVERIFY(c->isShown(false));
     QVERIFY(workspace()->xStackingOrder().contains(c));
 
     QSignalSpy enterSpy(&win, &HelperWindow::entered);
     QVERIFY(enterSpy.isValid());
     QSignalSpy leaveSpy(&win, &HelperWindow::left);
     QVERIFY(leaveSpy.isValid());
     QSignalSpy moveSpy(&win, &HelperWindow::mouseMoved);
     QVERIFY(moveSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
     QTRY_COMPARE(moveSpy.count(), 1);
 
     kwinApp()->platform()->pointerMotion(QPoint(60, 50), timestamp++);
     QTRY_COMPARE(moveSpy.count(), 2);
     QCOMPARE(moveSpy[1].first().toPoint(), QPoint(60, 50));
 
     kwinApp()->platform()->pointerMotion(QPoint(101, 50), timestamp++);
     QTRY_COMPARE(leaveSpy.count(), 1);
 
     // set a mask on the window
     win.setMask(QRegion(10, 20, 30, 40));
     // outside the mask we should not get an enter
     kwinApp()->platform()->pointerMotion(QPoint(5, 5), timestamp++);
     QVERIFY(!enterSpy.wait(100));
     QCOMPARE(enterSpy.count(), 1);
     // inside the mask we should still get an enter
     kwinApp()->platform()->pointerMotion(QPoint(25, 27), timestamp++);
     QTRY_COMPARE(enterSpy.count(), 2);
 }
 
 void InternalWindowTest::testPointerPressRelease()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::mousePressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::mouseReleased);
     QVERIFY(releaseSpy.isValid());
 
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
 
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QTRY_COMPARE(pressSpy.count(), 1);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
 }
 
 void InternalWindowTest::testPointerAxis()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy wheelSpy(&win, &HelperWindow::wheel);
     QVERIFY(wheelSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
 
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QTRY_COMPARE(wheelSpy.count(), 1);
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QTRY_COMPARE(wheelSpy.count(), 2);
 }
 
 void InternalWindowTest::testKeyboard_data()
 {
     QTest::addColumn<QPoint>("cursorPos");
 
     QTest::newRow("on Window") << QPoint(50, 50);
     QTest::newRow("outside Window") << QPoint(250, 250);
 }
 
 void InternalWindowTest::testKeyboard()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     quint32 timestamp = 1;
     QFETCH(QPoint, cursorPos);
     kwinApp()->platform()->pointerMotion(cursorPos, timestamp++);
 
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QTRY_COMPARE(pressSpy.count(), 1);
     QCOMPARE(releaseSpy.count(), 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
     QCOMPARE(pressSpy.count(), 1);
 }
 
 void InternalWindowTest::testKeyboardShowWithoutActivating()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setProperty("_q_showWithoutActivating", true);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     quint32 timestamp = 1;
     const QPoint cursorPos = QPoint(50, 50);
     kwinApp()->platform()->pointerMotion(cursorPos, timestamp++);
 
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QCOMPARE(pressSpy.count(), 0);
     QVERIFY(!pressSpy.wait(100));
     QCOMPARE(releaseSpy.count(), 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QCOMPARE(releaseSpy.count(), 0);
     QVERIFY(!releaseSpy.wait(100));
     QCOMPARE(pressSpy.count(), 0);
 }
 
 void InternalWindowTest::testKeyboardTriggersLeave()
 {
     // this test verifies that a leave event is sent to a client when an internal window
     // gets a key event
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QVERIFY(!keyboard.isNull());
     QVERIFY(keyboard->isValid());
     QSignalSpy enteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(leftSpy.isValid());
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
 
     // now let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isInternal());
 
     if (enteredSpy.isEmpty()) {
         QVERIFY(enteredSpy.wait());
     }
     QCOMPARE(enteredSpy.count(), 1);
 
     // create internal window
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     QVERIFY(leftSpy.isEmpty());
     QVERIFY(!leftSpy.wait(100));
 
     // now let's trigger a key, which should result in a leave
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QVERIFY(leftSpy.wait());
     QCOMPARE(pressSpy.count(), 1);
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
 
     // after hiding the internal window, next key press should trigger an enter
     win.hide();
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QVERIFY(enteredSpy.wait());
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 void InternalWindowTest::testTouch()
 {
     // touch events for internal windows are emulated through mouse events
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     QSignalSpy pressSpy(&win, &HelperWindow::mousePressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::mouseReleased);
     QVERIFY(releaseSpy.isValid());
     QSignalSpy moveSpy(&win, &HelperWindow::mouseMoved);
     QVERIFY(moveSpy.isValid());
 
     quint32 timestamp = 1;
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
     kwinApp()->platform()->touchDown(0, QPointF(50, 50), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // further touch down should not trigger
     kwinApp()->platform()->touchDown(1, QPointF(75, 75), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(releaseSpy.count(), 0);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // another press
     kwinApp()->platform()->touchDown(1, QPointF(10, 10), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // simulate the move
     QCOMPARE(moveSpy.count(), 0);
     kwinApp()->platform()->touchMotion(0, QPointF(80, 90), timestamp++);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // move on other ID should not do anything
     kwinApp()->platform()->touchMotion(1, QPointF(20, 30), timestamp++);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // now up our main point
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(releaseSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
 
     // and up the additional point
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(releaseSpy.count(), 1);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
 }
 
 void InternalWindowTest::testOpacity()
 {
     // this test verifies that opacity is properly synced from QWindow to InternalClient
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QCOMPARE(internalClient->opacity(), 0.5);
 
     QSignalSpy opacityChangedSpy(internalClient, &InternalClient::opacityChanged);
     QVERIFY(opacityChangedSpy.isValid());
     win.setOpacity(0.75);
     QCOMPARE(opacityChangedSpy.count(), 1);
     QCOMPARE(internalClient->opacity(), 0.75);
 }
 
 void InternalWindowTest::testMove()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->frameGeometry(), QRect(0, 0, 100, 100));
 
     // normal move should be synced
     internalClient->move(5, 10);
     QCOMPARE(internalClient->frameGeometry(), QRect(5, 10, 100, 100));
     QTRY_COMPARE(win.geometry(), QRect(5, 10, 100, 100));
     // another move should also be synced
     internalClient->move(10, 20);
     QCOMPARE(internalClient->frameGeometry(), QRect(10, 20, 100, 100));
     QTRY_COMPARE(win.geometry(), QRect(10, 20, 100, 100));
 
     // now move with a Geometry update blocker
     {
         GeometryUpdatesBlocker blocker(internalClient);
         internalClient->move(5, 10);
         // not synced!
         QCOMPARE(win.geometry(), QRect(10, 20, 100, 100));
     }
     // after destroying the blocker it should be synced
     QTRY_COMPARE(win.geometry(), QRect(5, 10, 100, 100));
 }
 
 void InternalWindowTest::testSkipCloseAnimation_data()
 {
     QTest::addColumn<bool>("initial");
 
     QTest::newRow("set") << true;
     QTest::newRow("not set") << false;
 }
 
 void InternalWindowTest::testSkipCloseAnimation()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     QFETCH(bool, initial);
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", initial);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->skipsCloseAnimation(), initial);
     QSignalSpy skipCloseChangedSpy(internalClient, &Toplevel::skipCloseAnimationChanged);
     QVERIFY(skipCloseChangedSpy.isValid());
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", !initial);
     QCOMPARE(skipCloseChangedSpy.count(), 1);
     QCOMPARE(internalClient->skipsCloseAnimation(), !initial);
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", initial);
     QCOMPARE(skipCloseChangedSpy.count(), 2);
     QCOMPARE(internalClient->skipsCloseAnimation(), initial);
 }
 
 void InternalWindowTest::testModifierClickUnrestrictedMove()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() & ~Qt::FramelessWindowHint);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isDecorated());
 
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // move cursor on window
     Cursor::setPos(internalClient->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QVERIFY(!internalClient->isMove());
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(internalClient->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QVERIFY(internalClient->isMove());
     // but releasing the key should end move/resize
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(!internalClient->isMove());
 }
 
 void InternalWindowTest::testModifierScroll()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() & ~Qt::FramelessWindowHint);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isDecorated());
 
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // move cursor on window
     Cursor::setPos(internalClient->frameGeometry().center());
 
     // set the opacity to 0.5
     internalClient->setOpacity(0.5);
     QCOMPARE(internalClient->opacity(), 0.5);
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(internalClient->opacity(), 0.6);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(internalClient->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 }
 
 void InternalWindowTest::testPopup()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() | Qt::Popup);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->isPopupWindow(), true);
 }
 
 void InternalWindowTest::testScale()
 {
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection,
         Q_ARG(int, 2),
         Q_ARG(QVector<QRect>, QVector<QRect>({QRect(0,0,1280, 1024), QRect(1280/2, 0, 1280, 1024)})),
         Q_ARG(QVector<int>, QVector<int>({2,2})));
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() | Qt::Popup);
     win.show();
     QCOMPARE(win.devicePixelRatio(), 2.0);
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QCOMPARE(internalClient->bufferScale(), 2);
 }
 
 void InternalWindowTest::testWindowType_data()
 {
     QTest::addColumn<NET::WindowType>("windowType");
 
     QTest::newRow("normal") << NET::Normal;
     QTest::newRow("desktop") << NET::Desktop;
     QTest::newRow("Dock") << NET::Dock;
     QTest::newRow("Toolbar") << NET::Toolbar;
     QTest::newRow("Menu") << NET::Menu;
     QTest::newRow("Dialog") << NET::Dialog;
     QTest::newRow("Utility") << NET::Utility;
     QTest::newRow("Splash") << NET::Splash;
     QTest::newRow("DropdownMenu") << NET::DropdownMenu;
     QTest::newRow("PopupMenu") << NET::PopupMenu;
     QTest::newRow("Tooltip") << NET::Tooltip;
     QTest::newRow("Notification") << NET::Notification;
     QTest::newRow("ComboBox") << NET::ComboBox;
     QTest::newRow("OnScreenDisplay") << NET::OnScreenDisplay;
     QTest::newRow("CriticalNotification") << NET::CriticalNotification;
 }
 
 void InternalWindowTest::testWindowType()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     QFETCH(NET::WindowType, windowType);
     KWindowSystem::setType(win.winId(), windowType);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->windowType(), windowType);
 }
 
 void InternalWindowTest::testChangeWindowType_data()
 {
     QTest::addColumn<NET::WindowType>("windowType");
 
     QTest::newRow("desktop") << NET::Desktop;
     QTest::newRow("Dock") << NET::Dock;
     QTest::newRow("Toolbar") << NET::Toolbar;
     QTest::newRow("Menu") << NET::Menu;
     QTest::newRow("Dialog") << NET::Dialog;
     QTest::newRow("Utility") << NET::Utility;
     QTest::newRow("Splash") << NET::Splash;
     QTest::newRow("DropdownMenu") << NET::DropdownMenu;
     QTest::newRow("PopupMenu") << NET::PopupMenu;
     QTest::newRow("Tooltip") << NET::Tooltip;
     QTest::newRow("Notification") << NET::Notification;
     QTest::newRow("ComboBox") << NET::ComboBox;
     QTest::newRow("OnScreenDisplay") << NET::OnScreenDisplay;
     QTest::newRow("CriticalNotification") << NET::CriticalNotification;
 }
 
 void InternalWindowTest::testChangeWindowType()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->windowType(), NET::Normal);
 
     QFETCH(NET::WindowType, windowType);
     KWindowSystem::setType(win.winId(), windowType);
     QTRY_COMPARE(internalClient->windowType(), windowType);
 
     KWindowSystem::setType(win.winId(), NET::Normal);
     QTRY_COMPARE(internalClient->windowType(), NET::Normal);
 }
 
 void InternalWindowTest::testEffectWindow()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->effectWindow());
     QCOMPARE(internalClient->effectWindow()->internalWindow(), &win);
 
     QCOMPARE(effects->findWindow(&win), internalClient->effectWindow());
     QCOMPARE(effects->findWindow(&win)->internalWindow(), &win);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::InternalWindowTest)
 #include "internal_window.moc"
diff --git a/autotests/integration/keyboard_layout_test.cpp b/autotests/integration/keyboard_layout_test.cpp
index dd9a07a19..147122ba2 100644
--- a/autotests/integration/keyboard_layout_test.cpp
+++ b/autotests/integration/keyboard_layout_test.cpp
@@ -1,511 +1,510 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "keyboard_input.h"
 #include "keyboard_layout.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 
 #include <KWayland/Client/surface.h>
 
 #include <QAction>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_keyboard_laout-0");
 
 class KeyboardLayoutTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testReconfigure();
     void testChangeLayoutThroughDBus();
     void testPerLayoutShortcut();
     void testDBusServiceExport();
     void testVirtualDesktopPolicy();
     void testWindowPolicy();
     void testApplicationPolicy();
     void testNumLock();
 
 private:
     void reconfigureLayouts();
 };
 
 void KeyboardLayoutTest::reconfigureLayouts()
 {
     // create DBus signal to reload
     QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/Layouts"), QStringLiteral("org.kde.keyboard"), QStringLiteral("reloadConfig"));
     QDBusConnection::sessionBus().send(message);
 }
 
 void KeyboardLayoutTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     kwinApp()->setKxkbConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     kwinApp()->setInputConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void KeyboardLayoutTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void KeyboardLayoutTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 class LayoutChangedSignalWrapper : public QObject
 {
     Q_OBJECT
 public:
     LayoutChangedSignalWrapper()
         : QObject()
     {
         QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("currentLayoutChanged"), this, SIGNAL(layoutChanged(QString)));
     }
 
 Q_SIGNALS:
     void layoutChanged(const QString &name);
 };
 
 void KeyboardLayoutTest::testReconfigure()
 {
     // verifies that we can change the keymap
 
     // default should be a keymap with only us layout
     auto xkb = input()->keyboard()->xkb();
     QCOMPARE(xkb->numberOfLayouts(), 1u);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     auto layouts = xkb->layoutNames();
     QCOMPARE(layouts.size(), 1);
     QVERIFY(layouts.contains(0));
     QCOMPARE(layouts[0], QStringLiteral("English (US)"));
 
     // create a new keymap
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("de,us"));
     layoutGroup.sync();
 
     reconfigureLayouts();
     // now we should have two layouts
     QTRY_COMPARE(xkb->numberOfLayouts(), 2u);
     // default layout is German
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     layouts = xkb->layoutNames();
     QCOMPARE(layouts.size(), 2);
     QVERIFY(layouts.contains(0));
     QVERIFY(layouts.contains(1));
     QCOMPARE(layouts[0], QStringLiteral("German"));
     QCOMPARE(layouts[1], QStringLiteral("English (US)"));
 }
 
 void KeyboardLayoutTest::testChangeLayoutThroughDBus()
 {
     // this test verifies that the layout can be changed through DBus
     // first configure layouts
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("de,us,de(neo)"));
     layoutGroup.sync();
     reconfigureLayouts();
     // now we should have two layouts
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     // default layout is German
     xkb->switchToLayout(0);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     LayoutChangedSignalWrapper wrapper;
     QSignalSpy layoutChangedSpy(&wrapper, &LayoutChangedSignalWrapper::layoutChanged);
     QVERIFY(layoutChangedSpy.isValid());
 
     // now change through DBus to english
     auto changeLayout = [] (const QString &layoutName) {
         QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
         msg << layoutName;
         return QDBusConnection::sessionBus().asyncCall(msg);
     };
     auto reply = changeLayout(QStringLiteral("English (US)"));
     reply.waitForFinished();
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     layoutChangedSpy.clear();
 
     // switch to a layout which does not exist
     reply = changeLayout(QStringLiteral("French"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), false);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     QVERIFY(!layoutChangedSpy.wait());
     QVERIFY(layoutChangedSpy.isEmpty());
 
     // switch to another layout should work
     reply = changeLayout(QStringLiteral("German"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     layoutChangedSpy.clear();
 
     // switching to same layout should also work
     reply = changeLayout(QStringLiteral("German"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     QVERIFY(!layoutChangedSpy.wait());
     QVERIFY(layoutChangedSpy.isEmpty());
 }
 
 void KeyboardLayoutTest::testPerLayoutShortcut()
 {
     // this test verifies that per-layout global shortcuts are working correctly.
     // first configure layouts
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
     layoutGroup.sync();
 
     // and create the global shortcuts
     const QString componentName = QStringLiteral("KDE Keyboard Layout Switcher");
     QAction *a = new QAction(this);
     a->setObjectName(QStringLiteral("Switch keyboard layout to English (US)"));
     a->setProperty("componentName", componentName);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>{Qt::CTRL+Qt::ALT+Qt::Key_1}, KGlobalAccel::NoAutoloading);
     delete a;
     a = new QAction(this);
     a->setObjectName(QStringLiteral("Switch keyboard layout to German"));
     a->setProperty("componentName", componentName);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>{Qt::CTRL+Qt::ALT+Qt::Key_2}, KGlobalAccel::NoAutoloading);
     delete a;
 
     reconfigureLayouts();
     // now we should have three layouts
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     // default layout is English
     xkb->switchToLayout(0);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     LayoutChangedSignalWrapper wrapper;
     QSignalSpy layoutChangedSpy(&wrapper, &LayoutChangedSignalWrapper::layoutChanged);
     QVERIFY(layoutChangedSpy.isValid());
 
     // now switch to English through the global shortcut
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     QVERIFY(layoutChangedSpy.wait());
     // now layout should be German
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     // release keys again
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     // switch back to English
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // release keys again
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
 }
 
 void KeyboardLayoutTest::testDBusServiceExport()
 {
     // verifies that the dbus service is only exported if there are at least two layouts
 
     // first configure layouts, with just one layout
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us"));
     layoutGroup.sync();
     reconfigureLayouts();
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 1u);
     // default layout is English
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // with one layout we should not have the dbus interface
     QTRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 
     // reconfigure to two layouts
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de"));
     layoutGroup.sync();
     reconfigureLayouts();
     QTRY_COMPARE(xkb->numberOfLayouts(), 2u);
     QTRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 
     // and back to one layout
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us"));
     layoutGroup.sync();
     reconfigureLayouts();
     QTRY_COMPARE(xkb->numberOfLayouts(), 1u);
     QTRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 }
 
 void KeyboardLayoutTest::testVirtualDesktopPolicy()
 {
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
     layoutGroup.writeEntry("SwitchMode", QStringLiteral("Desktop"));
     layoutGroup.sync();
     reconfigureLayouts();
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     VirtualDesktopManager::self()->setCount(4);
     QCOMPARE(VirtualDesktopManager::self()->count(), 4u);
 
     auto changeLayout = [] (const QString &layoutName) {
         QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
         msg << layoutName;
         return QDBusConnection::sessionBus().asyncCall(msg);
     };
     auto reply = changeLayout(QStringLiteral("German"));
     reply.waitForFinished();
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     // switch to another virtual desktop
     auto desktops = VirtualDesktopManager::self()->desktops();
     QCOMPARE(desktops.count(), 4);
     QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
     VirtualDesktopManager::self()->setCurrent(desktops.at(1));
     QCOMPARE(desktops.at(1), VirtualDesktopManager::self()->currentDesktop());
     // should be reset to English
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));reply = changeLayout(QStringLiteral("German (Neo 2)"));
     reply.waitForFinished();
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 
     // back to desktop 0 -> German
     VirtualDesktopManager::self()->setCurrent(desktops.at(0));
     QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
     // desktop 2 -> English
     VirtualDesktopManager::self()->setCurrent(desktops.at(2));
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // desktop 1 -> Neo
     VirtualDesktopManager::self()->setCurrent(desktops.at(1));
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 
     // remove virtual desktops
     VirtualDesktopManager::self()->setCount(1);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     // add another desktop
     VirtualDesktopManager::self()->setCount(2);
     // switching to it should result in going to default
     desktops = VirtualDesktopManager::self()->desktops();
     QCOMPARE(desktops.count(), 2);
     QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
     VirtualDesktopManager::self()->setCurrent(desktops.last());
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
 }
 
 void KeyboardLayoutTest::testWindowPolicy()
 {
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
     layoutGroup.writeEntry("SwitchMode", QStringLiteral("Window"));
     layoutGroup.sync();
     reconfigureLayouts();
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     // create a window
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c1 = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c1);
 
     // now switch layout
     auto changeLayout = [] (const QString &layoutName) {
         QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
         msg << layoutName;
         return QDBusConnection::sessionBus().asyncCall(msg);
     };
     auto reply = changeLayout(QStringLiteral("German"));
     reply.waitForFinished();
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     // create a second window
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 100), Qt::red);
     QVERIFY(c2);
     // this should have switched back to English
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // now change to another layout
     reply = changeLayout(QStringLiteral("German (Neo 2)"));
     reply.waitForFinished();
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 
     // activate other window
     workspace()->activateClient(c1);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
     workspace()->activateClient(c2);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 }
 
 void KeyboardLayoutTest::testApplicationPolicy()
 {
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
     layoutGroup.writeEntry("SwitchMode", QStringLiteral("WinClass"));
     layoutGroup.sync();
     reconfigureLayouts();
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     // create a window
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c1 = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c1);
 
     // now switch layout
     auto changeLayout = [] (const QString &layoutName) {
         QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
         msg << layoutName;
         return QDBusConnection::sessionBus().asyncCall(msg);
     };
     LayoutChangedSignalWrapper wrapper;
     QSignalSpy layoutChangedSpy(&wrapper, &LayoutChangedSignalWrapper::layoutChanged);
     QVERIFY(layoutChangedSpy.isValid());
     auto reply = changeLayout(QStringLiteral("German"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     reply.waitForFinished();
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     // create a second window
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 100), Qt::red);
     QVERIFY(c2);
     // it is the same application and should not switch the layout
     QVERIFY(!layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     // now change to another layout
     reply = changeLayout(QStringLiteral("German (Neo 2)"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 2);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 
     // activate other window
     workspace()->activateClient(c1);
     QVERIFY(!layoutChangedSpy.wait());
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
     workspace()->activateClient(c2);
     QVERIFY(!layoutChangedSpy.wait());
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 
     shellSurface2.reset();
     surface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(c2));
     QVERIFY(!layoutChangedSpy.wait());
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
 }
 
 void KeyboardLayoutTest::testNumLock()
 {
     qputenv("KWIN_FORCE_NUM_LOCK_EVALUATION", "1");
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us"));
     layoutGroup.sync();
     reconfigureLayouts();
 
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 1u);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     // by default not set
     QVERIFY(!xkb->leds().testFlag(Xkb::LED::NumLock));
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_NUMLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_NUMLOCK, timestamp++);
     // now it should be on
     QVERIFY(xkb->leds().testFlag(Xkb::LED::NumLock));
     // and back to off
     kwinApp()->platform()->keyboardKeyPressed(KEY_NUMLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_NUMLOCK, timestamp++);
     QVERIFY(!xkb->leds().testFlag(Xkb::LED::NumLock));
 
     // let's reconfigure to enable through config
     auto group = kwinApp()->inputConfig()->group("Keyboard");
     group.writeEntry("NumLock", 0);
     group.sync();
     xkb->reconfigure();
     // now it should be on
     QVERIFY(xkb->leds().testFlag(Xkb::LED::NumLock));
     // pressing should result in it being off
     kwinApp()->platform()->keyboardKeyPressed(KEY_NUMLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_NUMLOCK, timestamp++);
     QVERIFY(!xkb->leds().testFlag(Xkb::LED::NumLock));
 
     // pressing again should enable it
     kwinApp()->platform()->keyboardKeyPressed(KEY_NUMLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_NUMLOCK, timestamp++);
     QVERIFY(xkb->leds().testFlag(Xkb::LED::NumLock));
 
     // now reconfigure to disable on load
     group.writeEntry("NumLock", 1);
     group.sync();
     xkb->reconfigure();
     QVERIFY(!xkb->leds().testFlag(Xkb::LED::NumLock));
 }
 
 
 WAYLANDTEST_MAIN(KeyboardLayoutTest)
 #include "keyboard_layout_test.moc"
diff --git a/autotests/integration/keymap_creation_failure_test.cpp b/autotests/integration/keymap_creation_failure_test.cpp
index 8ec33b03a..069c677f0 100644
--- a/autotests/integration/keymap_creation_failure_test.cpp
+++ b/autotests/integration/keymap_creation_failure_test.cpp
@@ -1,102 +1,101 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "keyboard_input.h"
 #include "keyboard_layout.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_keymap_creation_failure-0");
 
 class KeymapCreationFailureTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testPointerButton();
 };
 
 void KeymapCreationFailureTest::initTestCase()
 {
     // situation for for BUG 381210
     // this will fail to create keymap
     qputenv("XKB_DEFAULT_RULES", "no");
     qputenv("XKB_DEFAULT_MODEL", "no");
     qputenv("XKB_DEFAULT_LAYOUT", "no");
     qputenv("XKB_DEFAULT_VARIANT", "no");
     qputenv("XKB_DEFAULT_OPTIONS", "no");
 
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     kwinApp()->setKxkbConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("no"));
     layoutGroup.writeEntry("Model", "no");
     layoutGroup.writeEntry("Options", "no");
     layoutGroup.sync();
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void KeymapCreationFailureTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void KeymapCreationFailureTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void KeymapCreationFailureTest::testPointerButton()
 {
     // test case for BUG 381210
     // pressing a pointer button results in crash
 
     // now create the crashing condition
     // which is sending in a pointer event
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, 0);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, 1);
 }
 
 WAYLANDTEST_MAIN(KeymapCreationFailureTest)
 #include "keymap_creation_failure_test.moc"
diff --git a/autotests/integration/kwin_wayland_test.h b/autotests/integration/kwin_wayland_test.h
index 237f20bfa..428a642ea 100644
--- a/autotests/integration/kwin_wayland_test.h
+++ b/autotests/integration/kwin_wayland_test.h
@@ -1,240 +1,239 @@
 /********************************************************************
 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_TEST_H
 #define KWIN_WAYLAND_TEST_H
 
 #include "../../main.h"
 
 // Qt
 #include <QtTest>
 
 // KWayland
 #include <KWayland/Client/xdgshell.h>
 
 namespace KWayland
 {
 namespace Client
 {
 class AppMenuManager;
 class ConnectionThread;
 class Compositor;
 class IdleInhibitManager;
 class PlasmaShell;
 class PlasmaWindowManagement;
 class PointerConstraints;
 class Seat;
 class ServerSideDecorationManager;
 class ShadowManager;
 class ShmPool;
 class SubCompositor;
 class SubSurface;
 class Surface;
 class XdgDecorationManager;
 }
 }
 
 namespace KWin
 {
 namespace Xwl
 {
 class Xwayland;
 }
 
 class AbstractClient;
-class XdgShellClient;
 
 class WaylandTestApplication : public ApplicationWaylandAbstract
 {
     Q_OBJECT
 public:
     WaylandTestApplication(OperationMode mode, int &argc, char **argv);
     ~WaylandTestApplication() override;
 
 protected:
     void performStartup() override;
 
 private:
     void createBackend();
     void continueStartupWithScreens();
     void continueStartupWithScene();
     void finalizeStartup();
 
     Xwl::Xwayland *m_xwayland = nullptr;
 };
 
 namespace Test
 {
 
 enum class AdditionalWaylandInterface {
     Seat = 1 << 0,
     Decoration = 1 << 1,
     PlasmaShell = 1 << 2,
     WindowManagement = 1 << 3,
     PointerConstraints = 1 << 4,
     IdleInhibition = 1 << 5,
     AppMenu = 1 << 6,
     ShadowManager = 1 << 7,
     XdgDecoration = 1 << 8,
 };
 Q_DECLARE_FLAGS(AdditionalWaylandInterfaces, AdditionalWaylandInterface)
 /**
  * Creates a Wayland Connection in a dedicated thread and creates various
  * client side objects which can be used to create windows.
  * @returns @c true if created successfully, @c false if there was an error
  * @see destroyWaylandConnection
  */
 bool setupWaylandConnection(AdditionalWaylandInterfaces flags = AdditionalWaylandInterfaces());
 
 /**
  * Destroys the Wayland Connection created with @link{setupWaylandConnection}.
  * This can be called from cleanup in order to ensure that no Wayland Connection
  * leaks into the next test method.
  * @see setupWaylandConnection
  */
 void destroyWaylandConnection();
 
 KWayland::Client::ConnectionThread *waylandConnection();
 KWayland::Client::Compositor *waylandCompositor();
 KWayland::Client::SubCompositor *waylandSubCompositor();
 KWayland::Client::ShadowManager *waylandShadowManager();
 KWayland::Client::ShmPool *waylandShmPool();
 KWayland::Client::Seat *waylandSeat();
 KWayland::Client::ServerSideDecorationManager *waylandServerSideDecoration();
 KWayland::Client::PlasmaShell *waylandPlasmaShell();
 KWayland::Client::PlasmaWindowManagement *waylandWindowManagement();
 KWayland::Client::PointerConstraints *waylandPointerConstraints();
 KWayland::Client::IdleInhibitManager *waylandIdleInhibitManager();
 KWayland::Client::AppMenuManager *waylandAppMenuManager();
 KWayland::Client::XdgDecorationManager *xdgDecorationManager();
 
 bool waitForWaylandPointer();
 bool waitForWaylandTouch();
 bool waitForWaylandKeyboard();
 
 void flushWaylandConnection();
 
 KWayland::Client::Surface *createSurface(QObject *parent = nullptr);
 KWayland::Client::SubSurface *createSubSurface(KWayland::Client::Surface *surface,
                                                KWayland::Client::Surface *parentSurface, QObject *parent = nullptr);
 enum class XdgShellSurfaceType {
     XdgShellV6,
     XdgShellStable
 };
 
 enum class CreationSetup {
     CreateOnly,
     CreateAndConfigure, /// commit and wait for the configure event, making this surface ready to commit buffers
 };
 
 KWayland::Client::XdgShellSurface *createXdgShellSurface(XdgShellSurfaceType type,
                                                          KWayland::Client::Surface *surface,
                                                          QObject *parent = nullptr,
                                                          CreationSetup creationSetup = CreationSetup::CreateAndConfigure);
 
 KWayland::Client::XdgShellSurface *createXdgShellV6Surface(KWayland::Client::Surface *surface,
                                                            QObject *parent = nullptr,
                                                            CreationSetup = CreationSetup::CreateAndConfigure);
 KWayland::Client::XdgShellSurface *createXdgShellStableSurface(KWayland::Client::Surface *surface,
                                                                QObject *parent = nullptr,
                                                                CreationSetup = CreationSetup::CreateAndConfigure);
 KWayland::Client::XdgShellPopup *createXdgShellStablePopup(KWayland::Client::Surface *surface,
                                                            KWayland::Client::XdgShellSurface *parentSurface,
                                                            const KWayland::Client::XdgPositioner &positioner,
                                                            QObject *parent = nullptr,
                                                            CreationSetup = CreationSetup::CreateAndConfigure);
 
 
 /**
  * Commits the XdgShellSurface to the given surface, and waits for the configure event from the compositor
  */
 void initXdgShellSurface(KWayland::Client::Surface *surface, KWayland::Client::XdgShellSurface *shellSurface);
 void initXdgShellPopup(KWayland::Client::Surface *surface, KWayland::Client::XdgShellPopup *popup);
 
 
 
 /**
  * Creates a shared memory buffer of @p size in @p color and attaches it to the @p surface.
  * The @p surface gets damaged and committed, thus it's rendered.
  */
 void render(KWayland::Client::Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format = QImage::Format_ARGB32_Premultiplied);
 
 /**
  * Creates a shared memory buffer using the supplied image @p img and attaches it to the @p surface
  */
 void render(KWayland::Client::Surface *surface, const QImage &img);
 
 /**
- * Waits till a new XdgShellClient is shown and returns the created XdgShellClient.
- * If no XdgShellClient gets shown during @p timeout @c null is returned.
+ * Waits till a new AbstractClient is shown and returns the created AbstractClient.
+ * If no AbstractClient gets shown during @p timeout @c null is returned.
  */
-XdgShellClient *waitForWaylandWindowShown(int timeout = 5000);
+AbstractClient *waitForWaylandWindowShown(int timeout = 5000);
 
 /**
  * Combination of @link{render} and @link{waitForWaylandWindowShown}.
  */
-XdgShellClient *renderAndWaitForShown(KWayland::Client::Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format = QImage::Format_ARGB32, int timeout = 5000);
+AbstractClient *renderAndWaitForShown(KWayland::Client::Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format = QImage::Format_ARGB32, int timeout = 5000);
 
 /**
  * Waits for the @p client to be destroyed.
  */
 bool waitForWindowDestroyed(AbstractClient *client);
 
 /**
  * Locks the screen and waits till the screen is locked.
  * @returns @c true if the screen could be locked, @c false otherwise
  */
 bool lockScreen();
 
 /**
  * Unlocks the screen and waits till the screen is unlocked.
  * @returns @c true if the screen could be unlocked, @c false otherwise
  */
 bool unlockScreen();
 }
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Test::AdditionalWaylandInterfaces)
 Q_DECLARE_METATYPE(KWin::Test::XdgShellSurfaceType)
 
 #define WAYLANDTEST_MAIN_HELPER(TestObject, DPI, OperationMode) \
 int main(int argc, char *argv[]) \
 { \
     setenv("QT_QPA_PLATFORM", "wayland-org.kde.kwin.qpa", true); \
     setenv("QT_QPA_PLATFORM_PLUGIN_PATH", QFileInfo(QString::fromLocal8Bit(argv[0])).absolutePath().toLocal8Bit().constData(), true); \
     setenv("KWIN_FORCE_OWN_QPA", "1", true); \
     qunsetenv("KDE_FULL_SESSION"); \
     qunsetenv("KDE_SESSION_VERSION"); \
     qunsetenv("XDG_SESSION_DESKTOP"); \
     qunsetenv("XDG_CURRENT_DESKTOP"); \
     DPI; \
     KWin::WaylandTestApplication app(OperationMode, argc, argv); \
     app.setAttribute(Qt::AA_Use96Dpi, true); \
     TestObject tc; \
     return QTest::qExec(&tc, argc, argv); \
 }
 
 #ifdef NO_XWAYLAND
 #define WAYLANDTEST_MAIN(TestObject) WAYLANDTEST_MAIN_HELPER(TestObject, QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps), KWin::Application::OperationModeWaylandOnly)
 #else
 #define WAYLANDTEST_MAIN(TestObject) WAYLANDTEST_MAIN_HELPER(TestObject, QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps), KWin::Application::OperationModeXwayland)
 #endif
 
 #endif
diff --git a/autotests/integration/kwinbindings_test.cpp b/autotests/integration/kwinbindings_test.cpp
index e90790843..ca61d426c 100644
--- a/autotests/integration/kwinbindings_test.cpp
+++ b/autotests/integration/kwinbindings_test.cpp
@@ -1,266 +1,265 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "input.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "scripting/scripting.h"
 #include "useractions.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingReply>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_kwinbindings-0");
 
 class KWinBindingsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testSwitchWindow();
     void testSwitchWindowScript();
     void testWindowToDesktop_data();
     void testWindowToDesktop();
 };
 
 
 void KWinBindingsTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void KWinBindingsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(640, 512));
 }
 
 void KWinBindingsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void KWinBindingsTest::testSwitchWindow()
 {
     // first create windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto c1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
     auto c4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c4->isActive());
     QVERIFY(c4 != c3);
     QVERIFY(c3 != c2);
     QVERIFY(c2 != c1);
 
     // let's position all windows
     c1->move(0, 0);
     c2->move(200, 0);
     c3->move(200, 200);
     c4->move(0, 200);
 
     // now let's trigger the shortcuts
 
     // invoke global shortcut through dbus
     auto invokeShortcut = [] (const QString &shortcut) {
         auto msg = QDBusMessage::createMethodCall(
             QStringLiteral("org.kde.kglobalaccel"),
             QStringLiteral("/component/kwin"),
             QStringLiteral("org.kde.kglobalaccel.Component"),
             QStringLiteral("invokeShortcut"));
         msg.setArguments(QList<QVariant>{shortcut});
         QDBusConnection::sessionBus().asyncCall(msg);
     };
     invokeShortcut(QStringLiteral("Switch Window Up"));
     QTRY_COMPARE(workspace()->activeClient(), c1);
     invokeShortcut(QStringLiteral("Switch Window Right"));
     QTRY_COMPARE(workspace()->activeClient(), c2);
     invokeShortcut(QStringLiteral("Switch Window Down"));
     QTRY_COMPARE(workspace()->activeClient(), c3);
     invokeShortcut(QStringLiteral("Switch Window Left"));
     QTRY_COMPARE(workspace()->activeClient(), c4);
     // test opposite direction
     invokeShortcut(QStringLiteral("Switch Window Left"));
     QTRY_COMPARE(workspace()->activeClient(), c3);
     invokeShortcut(QStringLiteral("Switch Window Down"));
     QTRY_COMPARE(workspace()->activeClient(), c2);
     invokeShortcut(QStringLiteral("Switch Window Right"));
     QTRY_COMPARE(workspace()->activeClient(), c1);
     invokeShortcut(QStringLiteral("Switch Window Up"));
     QTRY_COMPARE(workspace()->activeClient(), c4);
 }
 
 void KWinBindingsTest::testSwitchWindowScript()
 {
     QVERIFY(Scripting::self());
 
     // first create windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto c1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
     auto c4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c4->isActive());
     QVERIFY(c4 != c3);
     QVERIFY(c3 != c2);
     QVERIFY(c2 != c1);
 
     // let's position all windows
     c1->move(0, 0);
     c2->move(200, 0);
     c3->move(200, 200);
     c4->move(0, 200);
 
     auto runScript = [] (const QString &slot) {
         QTemporaryFile tmpFile;
         QVERIFY(tmpFile.open());
         QTextStream out(&tmpFile);
         out << "workspace." << slot << "()";
         out.flush();
 
         const int id = Scripting::self()->loadScript(tmpFile.fileName());
         QVERIFY(id != -1);
         QVERIFY(Scripting::self()->isScriptLoaded(tmpFile.fileName()));
         auto s = Scripting::self()->findScript(tmpFile.fileName());
         QVERIFY(s);
         QSignalSpy runningChangedSpy(s, &AbstractScript::runningChanged);
         QVERIFY(runningChangedSpy.isValid());
         s->run();
         QTRY_COMPARE(runningChangedSpy.count(), 1);
     };
 
     runScript(QStringLiteral("slotSwitchWindowUp"));
     QTRY_COMPARE(workspace()->activeClient(), c1);
     runScript(QStringLiteral("slotSwitchWindowRight"));
     QTRY_COMPARE(workspace()->activeClient(), c2);
     runScript(QStringLiteral("slotSwitchWindowDown"));
     QTRY_COMPARE(workspace()->activeClient(), c3);
     runScript(QStringLiteral("slotSwitchWindowLeft"));
     QTRY_COMPARE(workspace()->activeClient(), c4);
 }
 
 void KWinBindingsTest::testWindowToDesktop_data()
 {
     QTest::addColumn<int>("desktop");
 
     QTest::newRow("2") << 2;
     QTest::newRow("3") << 3;
     QTest::newRow("4") << 4;
     QTest::newRow("5") << 5;
     QTest::newRow("6") << 6;
     QTest::newRow("7") << 7;
     QTest::newRow("8") << 8;
     QTest::newRow("9") << 9;
     QTest::newRow("10") << 10;
     QTest::newRow("11") << 11;
     QTest::newRow("12") << 12;
     QTest::newRow("13") << 13;
     QTest::newRow("14") << 14;
     QTest::newRow("15") << 15;
     QTest::newRow("16") << 16;
     QTest::newRow("17") << 17;
     QTest::newRow("18") << 18;
     QTest::newRow("19") << 19;
     QTest::newRow("20") << 20;
 }
 
 void KWinBindingsTest::testWindowToDesktop()
 {
     // first go to desktop one
     VirtualDesktopManager::self()->setCurrent(VirtualDesktopManager::self()->desktops().first());
 
     // now create a window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QSignalSpy desktopChangedSpy(c, &AbstractClient::desktopChanged);
     QVERIFY(desktopChangedSpy.isValid());
     QCOMPARE(workspace()->activeClient(), c);
 
     QFETCH(int, desktop);
     VirtualDesktopManager::self()->setCount(desktop);
 
     // now trigger the shortcut
     auto invokeShortcut = [] (int desktop) {
         auto msg = QDBusMessage::createMethodCall(
             QStringLiteral("org.kde.kglobalaccel"),
             QStringLiteral("/component/kwin"),
             QStringLiteral("org.kde.kglobalaccel.Component"),
             QStringLiteral("invokeShortcut"));
         msg.setArguments(QList<QVariant>{QStringLiteral("Window to Desktop %1").arg(desktop)});
         QDBusConnection::sessionBus().asyncCall(msg);
     };
     invokeShortcut(desktop);
     QVERIFY(desktopChangedSpy.wait());
     QCOMPARE(c->desktop(), desktop);
     // back to desktop 1
     invokeShortcut(1);
     QVERIFY(desktopChangedSpy.wait());
     QCOMPARE(c->desktop(), 1);
     // invoke with one desktop too many
     invokeShortcut(desktop + 1);
     // that should fail
     QVERIFY(!desktopChangedSpy.wait(100));
 }
 
 WAYLANDTEST_MAIN(KWinBindingsTest)
 #include "kwinbindings_test.moc"
diff --git a/autotests/integration/lockscreen.cpp b/autotests/integration/lockscreen.cpp
index e25854007..eff058bf8 100644
--- a/autotests/integration/lockscreen.cpp
+++ b/autotests/integration/lockscreen.cpp
@@ -1,768 +1,766 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "scene.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 #include <KWayland/Server/seat_interface.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <KGlobalAccel>
 
 #include <linux/input.h>
 
 Q_DECLARE_METATYPE(Qt::Orientation)
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_lock_screen-0");
 
 class LockScreenTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testPointer();
     void testPointerButton();
     void testPointerAxis();
     void testKeyboard();
     void testScreenEdge();
     void testEffects();
     void testEffectsKeyboard();
     void testEffectsKeyboardAutorepeat();
     void testMoveWindow();
     void testPointerShortcut();
     void testAxisShortcut_data();
     void testAxisShortcut();
     void testKeyboardShortcut();
     void testTouch();
 
 private:
     void unlock();
     AbstractClient *showWindow();
     KWayland::Client::ConnectionThread *m_connection = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
     KWayland::Client::Seat *m_seat = nullptr;
     KWayland::Client::ShmPool *m_shm = nullptr;
     KWayland::Client::Shell *m_shell = nullptr;
 };
 
 class HelperEffect : public Effect
 {
     Q_OBJECT
 public:
     HelperEffect() {}
     ~HelperEffect() override {}
 
     void windowInputMouseEvent(QEvent*) override {
         emit inputEvent();
     }
     void grabbedKeyboardEvent(QKeyEvent *e) override {
         emit keyEvent(e->text());
     }
 
 Q_SIGNALS:
     void inputEvent();
     void keyEvent(const QString&);
 };
 
 #define LOCK \
     QVERIFY(!waylandServer()->isScreenLocked()); \
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged); \
     QVERIFY(lockStateChangedSpy.isValid()); \
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate); \
     QCOMPARE(lockStateChangedSpy.count(), 1); \
     QVERIFY(waylandServer()->isScreenLocked());
 
 #define UNLOCK \
     int expectedLockCount = 1; \
     if (ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::Locked) { \
         expectedLockCount = 2; \
     } \
     QCOMPARE(lockStateChangedSpy.count(), expectedLockCount); \
     unlock(); \
     if (lockStateChangedSpy.count() < expectedLockCount + 1) { \
         QVERIFY(lockStateChangedSpy.wait()); \
     } \
     QCOMPARE(lockStateChangedSpy.count(), expectedLockCount + 1); \
     QVERIFY(!waylandServer()->isScreenLocked());
 
 #define MOTION(target) \
     kwinApp()->platform()->pointerMotion(target, timestamp++)
 
 #define PRESS \
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++)
 
 #define RELEASE \
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++)
 
 #define KEYPRESS( key ) \
     kwinApp()->platform()->keyboardKeyPressed(key, timestamp++)
 
 #define KEYRELEASE( key ) \
     kwinApp()->platform()->keyboardKeyReleased(key, timestamp++)
 
 void LockScreenTest::unlock()
 {
     using namespace ScreenLocker;
     const auto children = KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
 }
 
 AbstractClient *LockScreenTest::showWindow()
 {
     using namespace KWayland::Client;
 #define VERIFY(statement) \
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
         return nullptr;
 #define COMPARE(actual, expected) \
     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\
         return nullptr;
 
     Surface *surface = Test::createSurface(m_compositor);
     VERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     VERIFY(shellSurface);
     // let's render
     auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
 
     VERIFY(c);
     COMPARE(workspace()->activeClient(), c);
 
 #undef VERIFY
 #undef COMPARE
 
     return c;
 }
 
 void LockScreenTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void LockScreenTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     m_connection = Test::waylandConnection();
     m_compositor = Test::waylandCompositor();
     m_shm = Test::waylandShmPool();
     m_seat = Test::waylandSeat();
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void LockScreenTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void LockScreenTest::testPointer()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer.data(), &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
 
     LOCK
 
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
 
     // simulate moving out in and out again
     MOTION(c->frameGeometry().center());
     MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
     MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
     QVERIFY(!leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(enteredSpy.count(), 1);
 
     // go back on the window
     MOTION(c->frameGeometry().center());
     // and unlock
     UNLOCK
 
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     // move on the window
     MOTION(c->frameGeometry().center() + QPoint(100, 100));
     QVERIFY(leftSpy.wait());
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 3);
 }
 
 void LockScreenTest::testPointerButton()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy buttonChangedSpy(pointer.data(), &Pointer::buttonStateChanged);
     QVERIFY(buttonChangedSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // and simulate a click
     PRESS;
     QVERIFY(buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(buttonChangedSpy.wait());
 
     LOCK
 
     // and simulate a click
     PRESS;
     QVERIFY(!buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(!buttonChangedSpy.wait());
 
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
 
     // and click again
     PRESS;
     QVERIFY(buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(buttonChangedSpy.wait());
 }
 
 void LockScreenTest::testPointerAxis()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy axisChangedSpy(pointer.data(), &Pointer::axisChanged);
     QVERIFY(axisChangedSpy.isValid());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // and simulate axis
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
 
     LOCK
 
     // and simulate axis
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(!axisChangedSpy.wait(100));
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(!axisChangedSpy.wait(100));
 
     // and unlock
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
 
     // and move axis again
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
 }
 
 void LockScreenTest::testKeyboard()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
     QVERIFY(!keyboard.isNull());
     QSignalSpy enteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy keyChangedSpy(keyboard.data(), &Keyboard::keyChanged);
     QVERIFY(keyChangedSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QVERIFY(enteredSpy.wait());
     QTRY_COMPARE(enteredSpy.count(), 1);
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 1);
     QCOMPARE(keyChangedSpy.at(0).at(0).value<quint32>(), quint32(KEY_A));
     QCOMPARE(keyChangedSpy.at(0).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
     QCOMPARE(keyChangedSpy.at(0).at(2).value<quint32>(), quint32(1));
     KEYRELEASE(KEY_A);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 2);
     QCOMPARE(keyChangedSpy.at(1).at(0).value<quint32>(), quint32(KEY_A));
     QCOMPARE(keyChangedSpy.at(1).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
     QCOMPARE(keyChangedSpy.at(1).at(2).value<quint32>(), quint32(2));
 
     LOCK
     QVERIFY(leftSpy.wait());
     KEYPRESS(KEY_B);
     KEYRELEASE(KEY_B);
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(keyChangedSpy.count(), 2);
 
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     KEYPRESS(KEY_C);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 3);
     KEYRELEASE(KEY_C);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 4);
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(keyChangedSpy.at(2).at(0).value<quint32>(), quint32(KEY_C));
     QCOMPARE(keyChangedSpy.at(3).at(0).value<quint32>(), quint32(KEY_C));
     QCOMPARE(keyChangedSpy.at(2).at(2).value<quint32>(), quint32(5));
     QCOMPARE(keyChangedSpy.at(3).at(2).value<quint32>(), quint32(6));
     QCOMPARE(keyChangedSpy.at(2).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
     QCOMPARE(keyChangedSpy.at(3).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
 }
 
 void LockScreenTest::testScreenEdge()
 {
     QSignalSpy screenEdgeSpy(ScreenEdges::self(), &ScreenEdges::approaching);
     QVERIFY(screenEdgeSpy.isValid());
     QCOMPARE(screenEdgeSpy.count(), 0);
 
     quint32 timestamp = 1;
     MOTION(QPoint(5, 5));
     QCOMPARE(screenEdgeSpy.count(), 1);
 
     LOCK
 
     MOTION(QPoint(4, 4));
     QCOMPARE(screenEdgeSpy.count(), 1);
 
     // and unlock
     UNLOCK
 
     MOTION(QPoint(5, 5));
     QCOMPARE(screenEdgeSpy.count(), 2);
 }
 
 void LockScreenTest::testEffects()
 {
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::inputEvent);
     QVERIFY(inputSpy.isValid());
     effects->startMouseInterception(effect.data(), Qt::ArrowCursor);
 
     quint32 timestamp = 1;
     QCOMPARE(inputSpy.count(), 0);
     MOTION(QPoint(5, 5));
     QCOMPARE(inputSpy.count(), 1);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 2);
     RELEASE;
     QCOMPARE(inputSpy.count(), 3);
 
     LOCK
 
     MOTION(QPoint(6, 6));
     QCOMPARE(inputSpy.count(), 3);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 3);
     RELEASE;
     QCOMPARE(inputSpy.count(), 3);
 
     UNLOCK
 
     MOTION(QPoint(5, 5));
     QCOMPARE(inputSpy.count(), 4);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 5);
     RELEASE;
     QCOMPARE(inputSpy.count(), 6);
 
     effects->stopMouseInterception(effect.data());
 }
 
 void LockScreenTest::testEffectsKeyboard()
 {
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
     QVERIFY(inputSpy.isValid());
     effects->grabKeyboard(effect.data());
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     KEYRELEASE(KEY_A);
     QCOMPARE(inputSpy.count(), 2);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
 
     LOCK
     KEYPRESS(KEY_B);
     QCOMPARE(inputSpy.count(), 2);
     KEYRELEASE(KEY_B);
     QCOMPARE(inputSpy.count(), 2);
 
     UNLOCK
     KEYPRESS(KEY_C);
     QCOMPARE(inputSpy.count(), 3);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
     KEYRELEASE(KEY_C);
     QCOMPARE(inputSpy.count(), 4);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
     QCOMPARE(inputSpy.at(3).first().toString(), QStringLiteral("c"));
 
     effects->ungrabKeyboard();
 }
 
 void LockScreenTest::testEffectsKeyboardAutorepeat()
 {
     // this test is just like testEffectsKeyboard, but tests auto repeat key events
     // while the key is pressed the Effect should get auto repeated events
     // but the lock screen should filter them out
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
     QVERIFY(inputSpy.isValid());
     effects->grabKeyboard(effect.data());
 
     // we need to configure the key repeat first. It is only enabled on libinput
     waylandServer()->seat()->setKeyRepeatInfo(25, 300);
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QVERIFY(inputSpy.wait());
     QVERIFY(inputSpy.count() > 1);
     // and still more events
     QVERIFY(inputSpy.wait());
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
 
     // now release
     inputSpy.clear();
     KEYRELEASE(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
 
     // while locked key repeat should not pass any events to the Effect
     LOCK
     KEYPRESS(KEY_B);
     QVERIFY(!inputSpy.wait(200));
     KEYRELEASE(KEY_B);
     QVERIFY(!inputSpy.wait(200));
 
     UNLOCK
     // don't test again, that's covered by testEffectsKeyboard
 
     effects->ungrabKeyboard();
 }
 
 void LockScreenTest::testMoveWindow()
 {
     using namespace KWayland::Client;
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QSignalSpy clientStepUserMovedResizedSpy(c, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     quint32 timestamp = 1;
 
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QEXPECT_FAIL("", "First event is ignored", Continue);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     // TODO adjust once the expected fail is fixed
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     // while locking our window should continue to be in move resize
     LOCK
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     UNLOCK
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, timestamp++);
     QVERIFY(!c->isMove());
 }
 
 void LockScreenTest::testPointerShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     input()->registerPointerShortcut(Qt::MetaModifier, Qt::LeftButton, action.data());
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
 #define PERFORM(expectedCount) \
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
     PRESS; \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount); \
     RELEASE; \
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount);
 
     PERFORM(1)
 
     // now the same thing with a locked screen
     LOCK
     PERFORM(1)
 
     // and as unlocked
     UNLOCK
     PERFORM(2)
 #undef PERFORM
 }
 
 
 void LockScreenTest::testAxisShortcut_data()
 {
     QTest::addColumn<Qt::Orientation>("direction");
     QTest::addColumn<int>("sign");
 
     QTest::newRow("up") << Qt::Vertical << 1;
     QTest::newRow("down") << Qt::Vertical << -1;
     QTest::newRow("left") << Qt::Horizontal << 1;
     QTest::newRow("right") << Qt::Horizontal << -1;
 }
 
 void LockScreenTest::testAxisShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     QFETCH(Qt::Orientation, direction);
     QFETCH(int, sign);
     PointerAxisDirection axisDirection = PointerAxisUp;
     if (direction == Qt::Vertical) {
         axisDirection = sign > 0 ? PointerAxisUp : PointerAxisDown;
     } else {
         axisDirection = sign > 0 ? PointerAxisLeft : PointerAxisRight;
     }
     input()->registerAxisShortcut(Qt::MetaModifier, axisDirection, action.data());
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
 #define PERFORM(expectedCount) \
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
     if (direction == Qt::Vertical) \
         kwinApp()->platform()->pointerAxisVertical(sign * 5.0, timestamp++); \
     else \
         kwinApp()->platform()->pointerAxisHorizontal(sign * 5.0, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount); \
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount);
 
     PERFORM(1)
 
     // now the same thing with a locked screen
     LOCK
     PERFORM(1)
 
     // and as unlocked
     UNLOCK
     PERFORM(2)
 #undef PERFORM
 }
 
 void LockScreenTest::testKeyboardShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName("LockScreenTest::testKeyboardShortcut");
     KGlobalAccel::self()->setDefaultShortcut(action.data(), QList<QKeySequence>{Qt::CTRL + Qt::META + Qt::ALT + Qt::Key_Space});
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::CTRL + Qt::META + Qt::ALT + Qt::Key_Space},
                                           KGlobalAccel::NoAutoloading);
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
     KEYPRESS(KEY_LEFTCTRL);
     KEYPRESS(KEY_LEFTMETA);
     KEYPRESS(KEY_LEFTALT);
     KEYPRESS(KEY_SPACE);
     QVERIFY(actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
 
     LOCK
     KEYPRESS(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
 
     UNLOCK
     KEYPRESS(KEY_SPACE);
     QVERIFY(actionSpy.wait());
     QCOMPARE(actionSpy.count(), 2);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 2);
     KEYRELEASE(KEY_LEFTCTRL);
     KEYRELEASE(KEY_LEFTMETA);
     KEYRELEASE(KEY_LEFTALT);
 }
 
 void LockScreenTest::testTouch()
 {
     using namespace KWayland::Client;
     auto touch = m_seat->createTouch(m_seat);
     QVERIFY(touch);
     QVERIFY(touch->isValid());
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QSignalSpy sequenceStartedSpy(touch, &Touch::sequenceStarted);
     QVERIFY(sequenceStartedSpy.isValid());
     QSignalSpy cancelSpy(touch, &Touch::sequenceCanceled);
     QVERIFY(cancelSpy.isValid());
     QSignalSpy pointRemovedSpy(touch, &Touch::pointRemoved);
     QVERIFY(pointRemovedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 1);
 
     LOCK
     QVERIFY(cancelSpy.wait());
 
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(!pointRemovedSpy.wait(100));
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     kwinApp()->platform()->touchMotion(1, QPointF(26, 26), timestamp++);
     kwinApp()->platform()->touchUp(1, timestamp++);
 
     UNLOCK
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 2);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(pointRemovedSpy.wait());
     QCOMPARE(pointRemovedSpy.count(), 1);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::LockScreenTest)
 #include "lockscreen.moc"
diff --git a/autotests/integration/maximize_test.cpp b/autotests/integration/maximize_test.cpp
index 4f3a16487..9b8cd7851 100644
--- a/autotests/integration/maximize_test.cpp
+++ b/autotests/integration/maximize_test.cpp
@@ -1,376 +1,375 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/plasmashell.h>
 
 #include <KWayland/Server/xdgdecoration_interface.h>
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_maximized-0");
 
 class TestMaximized : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMaximizedPassedToDeco();
     void testInitiallyMaximized();
     void testBorderlessMaximizedWindow();
     void testBorderlessMaximizedWindowNoClientSideDecoration();
 };
 
 void TestMaximized::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestMaximized::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration |
                                          Test::AdditionalWaylandInterface::XdgDecoration |
                                          Test::AdditionalWaylandInterface::PlasmaShell));
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestMaximized::cleanup()
 {
     Test::destroyWaylandConnection();
 
     // adjust config
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", false);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), false);
 }
 
 void TestMaximized::testMaximizedPassedToDeco()
 {
     // this test verifies that when a XdgShellClient gets maximized the Decoration receives the signal
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     auto decoration = client->decoration();
     QVERIFY(decoration);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
 
     // Wait for configure event that signals the client is active now.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     // When there are no borders, there is no change to them when maximizing.
     // TODO: we should test both cases with fixed fake decoration for autotests.
     const bool hasBorders = Decoration::DecorationBridge::self()->settings()->borderSize() != KDecoration2::BorderSize::None;
 
     // now maximize
     QSignalSpy bordersChangedSpy(decoration, &KDecoration2::Decoration::bordersChanged);
     QVERIFY(bordersChangedSpy.isValid());
     QSignalSpy maximizedChangedSpy(decoration->client().data(), &KDecoration2::DecoratedClient::maximizedChanged);
     QVERIFY(maximizedChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024 - decoration->borderTop()));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), configureRequestedSpy.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     // If no borders, there is only the initial geometry shape change, but none through border resizing.
     QCOMPARE(frameGeometryChangedSpy.count(), hasBorders ? 2 : 1);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(maximizedChangedSpy.count(), 1);
     QCOMPARE(maximizedChangedSpy.last().first().toBool(), true);
     QCOMPARE(bordersChangedSpy.count(), hasBorders ? 1 : 0);
     QCOMPARE(decoration->borderLeft(), 0);
     QCOMPARE(decoration->borderBottom(), 0);
     QCOMPARE(decoration->borderRight(), 0);
     QVERIFY(decoration->borderTop() != 0);
 
     // now unmaximize again
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), hasBorders ? 4 : 2);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(maximizedChangedSpy.count(), 2);
     QCOMPARE(maximizedChangedSpy.last().first().toBool(), false);
     QCOMPARE(bordersChangedSpy.count(), hasBorders ? 2 : 0);
     QVERIFY(decoration->borderTop() != 0);
     QVERIFY(decoration->borderLeft() != !hasBorders);
     QVERIFY(decoration->borderRight() != !hasBorders);
     QVERIFY(decoration->borderBottom() != !hasBorders);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testInitiallyMaximized()
 {
     // This test verifies that a window created as maximized, will be maximized.
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(
         Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     shellSurface->setMaximized(true);
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Now let's render in an incorrect size.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 100, 50));
     QEXPECT_FAIL("", "Should go out of maximzied", Continue);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testBorderlessMaximizedWindow()
 {
     // This test verifies that a maximized client looses it's server-side
     // decoration when the borderless maximized option is on.
 
     // Enable the borderless maximized windows option.
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", true);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), true);
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(
         Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<XdgDecoration> decoration(
         Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
     QSignalSpy decorationConfiguredSpy(decoration.data(), &XdgDecoration::modeChanged);
     QVERIFY(decorationConfiguredSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     decoration->setMode(XdgDecoration::Mode::ServerSide);
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->isDecorated(), true);
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Maximize the client.
     const QRect maximizeRestoreGeometry = client->frameGeometry();
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->isDecorated(), false);
 
     // Restore the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), maximizeRestoreGeometry);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->isDecorated(), true);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testBorderlessMaximizedWindowNoClientSideDecoration()
 {
     // test case verifies that borderless maximized windows doesn't cause
     // clients to render client-side decorations instead (BUG 405385)
 
     // adjust config
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", true);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), true);
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> xdgShellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(xdgShellSurface.data()));
 
     QSignalSpy decorationConfiguredSpy(deco.data(), &XdgDecoration::modeChanged);
     QVERIFY(decorationConfiguredSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(xdgShellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(xdgShellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
 
     QVERIFY(client->isDecorated());
     QVERIFY(!client->noBorder());
     configureRequestedSpy.wait();
     QCOMPARE(decorationConfiguredSpy.count(), 1);
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 
     // go to maximized
     xdgShellSurface->setMaximized(true);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toInt());
     }
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     // no deco
     QVERIFY(!client->isDecorated());
     QVERIFY(client->noBorder());
     // but still server-side
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 
     // go back to normal
     xdgShellSurface->setMaximized(false);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 2);
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toInt());
     }
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     QVERIFY(client->isDecorated());
     QVERIFY(!client->noBorder());
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 }
 
 WAYLANDTEST_MAIN(TestMaximized)
 #include "maximize_test.moc"
diff --git a/autotests/integration/move_resize_window_test.cpp b/autotests/integration/move_resize_window_test.cpp
index f7ef81f54..2b977403a 100644
--- a/autotests/integration/move_resize_window_test.cpp
+++ b/autotests/integration/move_resize_window_test.cpp
@@ -1,1214 +1,1212 @@
 
 /********************************************************************
 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 "kwin_wayland_test.h"
 #include "atoms.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "effects.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "deleted.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 #include <linux/input.h>
 #include <xcb/xcb_icccm.h>
 
 Q_DECLARE_METATYPE(KWin::QuickTileMode)
 Q_DECLARE_METATYPE(KWin::MaximizeMode)
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_quick_tiling-0");
 
 class MoveResizeWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testMove();
     void testResize();
     void testPackTo_data();
     void testPackTo();
     void testPackAgainstClient_data();
     void testPackAgainstClient();
     void testGrowShrink_data();
     void testGrowShrink();
     void testPointerMoveEnd_data();
     void testPointerMoveEnd();
     void testClientSideMove_data();
     void testClientSideMove();
     void testPlasmaShellSurfaceMovable_data();
     void testPlasmaShellSurfaceMovable();
     void testNetMove();
     void testAdjustClientGeometryOfAutohidingX11Panel_data();
     void testAdjustClientGeometryOfAutohidingX11Panel();
     void testAdjustClientGeometryOfAutohidingWaylandPanel_data();
     void testAdjustClientGeometryOfAutohidingWaylandPanel();
     void testResizeForVirtualKeyboard();
     void testResizeForVirtualKeyboardWithMaximize();
     void testResizeForVirtualKeyboardWithFullScreen();
     void testDestroyMoveClient();
     void testDestroyResizeClient();
     void testUnmapMoveClient();
     void testUnmapResizeClient();
 
 private:
     KWayland::Client::ConnectionThread *m_connection = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
 };
 
 void MoveResizeWindowTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::Deleted *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::MaximizeMode>("MaximizeMode");
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 1);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
 }
 
 void MoveResizeWindowTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::PlasmaShell | Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     m_connection = Test::waylandConnection();
     m_compositor = Test::waylandCompositor();
 
     screens()->setCurrent(0);
 }
 
 void MoveResizeWindowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void MoveResizeWindowTest::testMove()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QSignalSpy sizeChangeSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeSpy.isValid());
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QSignalSpy startMoveResizedSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(startMoveResizedSpy.isValid());
     QSignalSpy moveResizedChangedSpy(c, &AbstractClient::moveResizedChanged);
     QVERIFY(moveResizedChangedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(c, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(c, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // effects signal handlers
     QSignalSpy windowStartUserMovedResizedSpy(effects, &EffectsHandler::windowStartUserMovedResized);
     QVERIFY(windowStartUserMovedResizedSpy.isValid());
     QSignalSpy windowStepUserMovedResizedSpy(effects, &EffectsHandler::windowStepUserMovedResized);
     QVERIFY(windowStepUserMovedResizedSpy.isValid());
     QSignalSpy windowFinishUserMovedResizedSpy(effects, &EffectsHandler::windowFinishUserMovedResized);
     QVERIFY(windowFinishUserMovedResizedSpy.isValid());
 
     // begin move
     QVERIFY(workspace()->moveResizeClient() == nullptr);
     QCOMPARE(c->isMove(), false);
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), c);
     QCOMPARE(startMoveResizedSpy.count(), 1);
     QCOMPARE(moveResizedChangedSpy.count(), 1);
     QCOMPARE(windowStartUserMovedResizedSpy.count(), 1);
     QCOMPARE(c->isMove(), true);
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
 
     // send some key events, not going through input redirection
     const QPoint cursorPos = Cursor::pos();
     c->keyPressEvent(Qt::Key_Right);
     c->updateMoveResize(Cursor::pos());
     QCOMPARE(Cursor::pos(), cursorPos + QPoint(8, 0));
     QEXPECT_FAIL("", "First event is ignored", Continue);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     clientStepUserMovedResizedSpy.clear();
     windowStepUserMovedResizedSpy.clear();
 
     c->keyPressEvent(Qt::Key_Right);
     c->updateMoveResize(Cursor::pos());
     QCOMPARE(Cursor::pos(), cursorPos + QPoint(16, 0));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(windowStepUserMovedResizedSpy.count(), 1);
 
     c->keyPressEvent(Qt::Key_Down | Qt::ALT);
     c->updateMoveResize(Cursor::pos());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(windowStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(c->frameGeometry(), QRect(16, 32, 100, 50));
     QCOMPARE(Cursor::pos(), cursorPos + QPoint(16, 32));
 
     // let's end
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     c->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(moveResizedChangedSpy.count(), 2);
     QCOMPARE(windowFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(c->frameGeometry(), QRect(16, 32, 100, 50));
     QCOMPARE(c->isMove(), false);
     QVERIFY(workspace()->moveResizeClient() == nullptr);
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 void MoveResizeWindowTest::testResize()
 {
     // a test case which manually resizes a window
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(
         surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QVERIFY(!shellSurface.isNull());
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // Let's render.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QSignalSpy surfaceSizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(surfaceSizeChangedSpy.isValid());
 
     // We have to receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy startMoveResizedSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(startMoveResizedSpy.isValid());
     QSignalSpy moveResizedChangedSpy(c, &AbstractClient::moveResizedChanged);
     QVERIFY(moveResizedChangedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(c, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(c, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // begin resize
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(c->isMove(), false);
     QCOMPARE(c->isResize(), false);
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), c);
     QCOMPARE(startMoveResizedSpy.count(), 1);
     QCOMPARE(moveResizedChangedSpy.count(), 1);
     QCOMPARE(c->isResize(), true);
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
 
     // Trigger a change.
     const QPoint cursorPos = Cursor::pos();
     c->keyPressEvent(Qt::Key_Right);
     c->updateMoveResize(Cursor::pos());
     QCOMPARE(Cursor::pos(), cursorPos + QPoint(8, 0));
 
     // The client should receive a configure event with the new size.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(surfaceSizeChangedSpy.count(), 1);
     QCOMPARE(surfaceSizeChangedSpy.last().first().toSize(), QSize(108, 50));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
 
     // Now render new size.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(108, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 108, 50));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     // Go down.
     c->keyPressEvent(Qt::Key_Down);
     c->updateMoveResize(Cursor::pos());
     QCOMPARE(Cursor::pos(), cursorPos + QPoint(8, 8));
 
     // The client should receive another configure event.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 5);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(surfaceSizeChangedSpy.count(), 2);
     QCOMPARE(surfaceSizeChangedSpy.last().first().toSize(), QSize(108, 58));
 
     // Now render new size.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(108, 58), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 108, 58));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
 
     // Let's finalize the resize operation.
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     c->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(moveResizedChangedSpy.count(), 2);
     QCOMPARE(c->isResize(), false);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QEXPECT_FAIL("", "XdgShellClient currently doesn't send final configure event", Abort);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 6);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // Destroy the client.
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 void MoveResizeWindowTest::testPackTo_data()
 {
     QTest::addColumn<QString>("methodCall");
     QTest::addColumn<QRect>("expectedGeometry");
 
     QTest::newRow("left")  << QStringLiteral("slotWindowPackLeft")  << QRect(0, 487, 100, 50);
     QTest::newRow("up")    << QStringLiteral("slotWindowPackUp")    << QRect(590, 0, 100, 50);
     QTest::newRow("right") << QStringLiteral("slotWindowPackRight") << QRect(1180, 487, 100, 50);
     QTest::newRow("down")  << QStringLiteral("slotWindowPackDown")  << QRect(590, 974, 100, 50);
 }
 
 void MoveResizeWindowTest::testPackTo()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QSignalSpy sizeChangeSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeSpy.isValid());
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
 
     // let's place it centered
     Placement::self()->placeCentered(c, QRect(0, 0, 1280, 1024));
     QCOMPARE(c->frameGeometry(), QRect(590, 487, 100, 50));
 
     QFETCH(QString, methodCall);
     QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
     QTEST(c->frameGeometry(), "expectedGeometry");
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 void MoveResizeWindowTest::testPackAgainstClient_data()
 {
     QTest::addColumn<QString>("methodCall");
     QTest::addColumn<QRect>("expectedGeometry");
 
     QTest::newRow("left")  << QStringLiteral("slotWindowPackLeft")  << QRect(10, 487, 100, 50);
     QTest::newRow("up")    << QStringLiteral("slotWindowPackUp")    << QRect(590, 10, 100, 50);
     QTest::newRow("right") << QStringLiteral("slotWindowPackRight") << QRect(1170, 487, 100, 50);
     QTest::newRow("down")  << QStringLiteral("slotWindowPackDown")  << QRect(590, 964, 100, 50);
 }
 
 void MoveResizeWindowTest::testPackAgainstClient()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface1(Test::createSurface());
     QVERIFY(!surface1.isNull());
     QScopedPointer<Surface> surface2(Test::createSurface());
     QVERIFY(!surface2.isNull());
     QScopedPointer<Surface> surface3(Test::createSurface());
     QVERIFY(!surface3.isNull());
     QScopedPointer<Surface> surface4(Test::createSurface());
     QVERIFY(!surface4.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     QVERIFY(!shellSurface1.isNull());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     QVERIFY(!shellSurface2.isNull());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     QVERIFY(!shellSurface3.isNull());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
     QVERIFY(!shellSurface4.isNull());
     auto renderWindow = [this] (Surface *surface, const QString &methodCall, const QRect &expectedGeometry) {
         // let's render
         auto c = Test::renderAndWaitForShown(surface, QSize(10, 10), Qt::blue);
 
         QVERIFY(c);
         QCOMPARE(workspace()->activeClient(), c);
         QCOMPARE(c->frameGeometry().size(), QSize(10, 10));
         // let's place it centered
         Placement::self()->placeCentered(c, QRect(0, 0, 1280, 1024));
         QCOMPARE(c->frameGeometry(), QRect(635, 507, 10, 10));
         QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
         QCOMPARE(c->frameGeometry(), expectedGeometry);
     };
     renderWindow(surface1.data(), QStringLiteral("slotWindowPackLeft"),  QRect(0, 507, 10, 10));
     renderWindow(surface2.data(), QStringLiteral("slotWindowPackUp"),    QRect(635, 0, 10, 10));
     renderWindow(surface3.data(), QStringLiteral("slotWindowPackRight"), QRect(1270, 507, 10, 10));
     renderWindow(surface4.data(), QStringLiteral("slotWindowPackDown"),  QRect(635, 1014, 10, 10));
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     // let's place it centered
     Placement::self()->placeCentered(c, QRect(0, 0, 1280, 1024));
     QCOMPARE(c->frameGeometry(), QRect(590, 487, 100, 50));
 
     QFETCH(QString, methodCall);
     QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
     QTEST(c->frameGeometry(), "expectedGeometry");
 }
 
 void MoveResizeWindowTest::testGrowShrink_data()
 {
     QTest::addColumn<QString>("methodCall");
     QTest::addColumn<QRect>("expectedGeometry");
 
     QTest::newRow("grow vertical")     << QStringLiteral("slotWindowGrowVertical")     << QRect(590, 487, 100, 537);
     QTest::newRow("grow horizontal")   << QStringLiteral("slotWindowGrowHorizontal")   << QRect(590, 487, 690, 50);
     QTest::newRow("shrink vertical")   << QStringLiteral("slotWindowShrinkVertical")   << QRect(590, 487, 100, 23);
     QTest::newRow("shrink horizontal") << QStringLiteral("slotWindowShrinkHorizontal") << QRect(590, 487, 40, 50);
 }
 
 void MoveResizeWindowTest::testGrowShrink()
 {
     using namespace KWayland::Client;
 
     // block geometry helper
     QScopedPointer<Surface> surface1(Test::createSurface());
     QVERIFY(!surface1.isNull());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     QVERIFY(!shellSurface1.isNull());
     Test::render(surface1.data(), QSize(650, 514), Qt::blue);
     QVERIFY(Test::waitForWaylandWindowShown());
     workspace()->slotWindowPackRight();
     workspace()->slotWindowPackDown();
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QSignalSpy sizeChangeSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeSpy.isValid());
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // let's place it centered
     Placement::self()->placeCentered(c, QRect(0, 0, 1280, 1024));
     QCOMPARE(c->frameGeometry(), QRect(590, 487, 100, 50));
 
     QFETCH(QString, methodCall);
     QMetaObject::invokeMethod(workspace(), methodCall.toLocal8Bit().constData());
     QVERIFY(sizeChangeSpy.wait());
     Test::render(surface.data(), shellSurface->size(), Qt::red);
 
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     m_connection->flush();
     QVERIFY(frameGeometryChangedSpy.wait());
     QTEST(c->frameGeometry(), "expectedGeometry");
 }
 
 void MoveResizeWindowTest::testPointerMoveEnd_data()
 {
     QTest::addColumn<int>("additionalButton");
 
     QTest::newRow("BTN_RIGHT")   << BTN_RIGHT;
     QTest::newRow("BTN_MIDDLE")  << BTN_MIDDLE;
     QTest::newRow("BTN_SIDE")    << BTN_SIDE;
     QTest::newRow("BTN_EXTRA")   << BTN_EXTRA;
     QTest::newRow("BTN_FORWARD") << BTN_FORWARD;
     QTest::newRow("BTN_BACK")    << BTN_BACK;
     QTest::newRow("BTN_TASK")    << BTN_TASK;
     for (int i=BTN_TASK + 1; i < BTN_JOYSTICK; i++) {
         QTest::newRow(QByteArray::number(i, 16).constData()) << i;
     }
 }
 
 void MoveResizeWindowTest::testPointerMoveEnd()
 {
     // this test verifies that moving a window through pointer only ends if all buttons are released
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QSignalSpy sizeChangeSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeSpy.isValid());
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(c, workspace()->activeClient());
     QVERIFY(!c->isMove());
 
     // let's trigger the left button
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(!c->isMove());
     workspace()->slotWindowMove();
     QVERIFY(c->isMove());
 
     // let's press another button
     QFETCH(int, additionalButton);
     kwinApp()->platform()->pointerButtonPressed(additionalButton, timestamp++);
     QVERIFY(c->isMove());
 
     // release the left button, should still have the window moving
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(c->isMove());
 
     // but releasing the other button should now end moving
     kwinApp()->platform()->pointerButtonReleased(additionalButton, timestamp++);
     QVERIFY(!c->isMove());
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 void MoveResizeWindowTest::testClientSideMove_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void MoveResizeWindowTest::testClientSideMove()
 {
     using namespace KWayland::Client;
     Cursor::setPos(640, 512);
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy buttonSpy(pointer.data(), &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // move pointer into center of geometry
     const QRect startGeometry = c->frameGeometry();
     Cursor::setPos(startGeometry.center());
     QVERIFY(pointerEnteredSpy.wait());
     QCOMPARE(pointerEnteredSpy.first().last().toPoint(), QPoint(49, 24));
     // simulate press
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(buttonSpy.wait());
     QSignalSpy moveStartSpy(c, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(moveStartSpy.isValid());
     shellSurface->requestMove(Test::waylandSeat(), buttonSpy.first().first().value<quint32>());
     QVERIFY(moveStartSpy.wait());
     QCOMPARE(c->isMove(), true);
     QVERIFY(pointerLeftSpy.wait());
 
     // move a bit
     QSignalSpy clientMoveStepSpy(c, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientMoveStepSpy.isValid());
     const QPoint startPoint = startGeometry.center();
     const int dragDistance = QApplication::startDragDistance();
     // Why?
     kwinApp()->platform()->pointerMotion(startPoint + QPoint(dragDistance, dragDistance) + QPoint(6, 6), timestamp++);
     QCOMPARE(clientMoveStepSpy.count(), 1);
 
     // and release again
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(pointerEnteredSpy.wait());
     QCOMPARE(c->isMove(), false);
     QCOMPARE(c->frameGeometry(), startGeometry.translated(QPoint(dragDistance, dragDistance) + QPoint(6, 6)));
     QCOMPARE(pointerEnteredSpy.last().last().toPoint(), QPoint(49, 24));
 }
 
 void MoveResizeWindowTest::testPlasmaShellSurfaceMovable_data()
 {
     QTest::addColumn<KWayland::Client::PlasmaShellSurface::Role>("role");
     QTest::addColumn<bool>("movable");
     QTest::addColumn<bool>("movableAcrossScreens");
     QTest::addColumn<bool>("resizable");
 
     QTest::newRow("normal")  << KWayland::Client::PlasmaShellSurface::Role::Normal          << true  << true  << true;
     QTest::newRow("desktop") << KWayland::Client::PlasmaShellSurface::Role::Desktop         << false << false << false;
     QTest::newRow("panel")   << KWayland::Client::PlasmaShellSurface::Role::Panel           << false << false << false;
     QTest::newRow("osd")     << KWayland::Client::PlasmaShellSurface::Role::OnScreenDisplay << false << false << false;
 }
 
 void MoveResizeWindowTest::testPlasmaShellSurfaceMovable()
 {
     // this test verifies that certain window types from PlasmaShellSurface are not moveable or resizable
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     // and a PlasmaShellSurface
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     QFETCH(KWayland::Client::PlasmaShellSurface::Role, role);
     plasmaSurface->setRole(role);
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QTEST(c->isMovable(), "movable");
     QTEST(c->isMovableAcrossScreens(), "movableAcrossScreens");
     QTEST(c->isResizable(), "resizable");
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void MoveResizeWindowTest::testNetMove()
 {
     // this test verifies that a move request for an X11 window through NET API works
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       0, 0, 100, 100,
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, 0, 0);
     xcb_icccm_size_hints_set_size(&hints, 1, 100, 100);
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     // let's set a no-border
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::WMWindowType, NET::Properties2());
     winInfo.setWindowType(NET::Override);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     const QRect origGeo = client->frameGeometry();
 
     // let's move the cursor outside the window
     Cursor::setPos(screens()->geometry(0).center());
     QVERIFY(!origGeo.contains(Cursor::pos()));
 
     QSignalSpy moveStartSpy(client, &X11Client::clientStartUserMovedResized);
     QVERIFY(moveStartSpy.isValid());
     QSignalSpy moveEndSpy(client, &X11Client::clientFinishUserMovedResized);
     QVERIFY(moveEndSpy.isValid());
     QSignalSpy moveStepSpy(client, &X11Client::clientStepUserMovedResized);
     QVERIFY(moveStepSpy.isValid());
     QVERIFY(!workspace()->moveResizeClient());
 
     // use NETRootInfo to trigger a move request
     NETRootInfo root(c.data(), NET::Properties());
     root.moveResizeRequest(w, origGeo.center().x(), origGeo.center().y(), NET::Move);
     xcb_flush(c.data());
 
     QVERIFY(moveStartSpy.wait());
     QCOMPARE(workspace()->moveResizeClient(), client);
     QVERIFY(client->isMove());
     QCOMPARE(client->geometryRestore(), origGeo);
     QCOMPARE(Cursor::pos(), origGeo.center());
 
     // let's move a step
     Cursor::setPos(Cursor::pos() + QPoint(10, 10));
     QCOMPARE(moveStepSpy.count(), 1);
     QCOMPARE(moveStepSpy.first().last().toRect(), origGeo.translated(10, 10));
 
     // let's cancel the move resize again through the net API
     root.moveResizeRequest(w, client->frameGeometry().center().x(), client->frameGeometry().center().y(), NET::MoveResizeCancel);
     xcb_flush(c.data());
     QVERIFY(moveEndSpy.wait());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingX11Panel_data()
 {
     QTest::addColumn<QRect>("panelGeometry");
     QTest::addColumn<QPoint>("targetPoint");
     QTest::addColumn<QPoint>("expectedAdjustedPoint");
     QTest::addColumn<quint32>("hideLocation");
 
     QTest::newRow("top") << QRect(0, 0, 100, 20) << QPoint(50, 25) << QPoint(50, 20) << 0u;
     QTest::newRow("bottom") << QRect(0, 1024-20, 100, 20) << QPoint(50, 1024 - 25 - 50) << QPoint(50, 1024 - 20 - 50) << 2u;
     QTest::newRow("left") << QRect(0, 0, 20, 100) << QPoint(25, 50) << QPoint(20, 50) << 3u;
     QTest::newRow("right") << QRect(1280 - 20, 0, 20, 100) << QPoint(1280 - 25 - 100, 50) << QPoint(1280 - 20 - 100, 50) << 1u;
 }
 
 void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingX11Panel()
 {
     // this test verifies that auto hiding panels are ignored when adjusting client geometry
     // see BUG 365892
 
     // first create our panel
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     QFETCH(QRect, panelGeometry);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       panelGeometry.x(), panelGeometry.y(), panelGeometry.width(), panelGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, panelGeometry.x(), panelGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, panelGeometry.width(), panelGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::WMWindowType, NET::Properties2());
     winInfo.setWindowType(NET::Dock);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *panel = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(panel);
     QCOMPARE(panel->window(), w);
     QCOMPARE(panel->frameGeometry(), panelGeometry);
     QVERIFY(panel->isDock());
 
     // let's create a window
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     auto testWindow = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(testWindow);
     QVERIFY(testWindow->isMovable());
     // panel is not yet hidden, we should snap against it
     QFETCH(QPoint, targetPoint);
     QTEST(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), "expectedAdjustedPoint");
 
     // now let's hide the panel
     QSignalSpy panelHiddenSpy(panel, &AbstractClient::windowHidden);
     QVERIFY(panelHiddenSpy.isValid());
     QFETCH(quint32, hideLocation);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atoms->kde_screen_edge_show, XCB_ATOM_CARDINAL, 32, 1, &hideLocation);
     xcb_flush(c.data());
     QVERIFY(panelHiddenSpy.wait());
 
     // now try to snap again
     QCOMPARE(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), targetPoint);
 
     // and destroy the panel again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy panelClosedSpy(panel, &X11Client::windowClosed);
     QVERIFY(panelClosedSpy.isValid());
     QVERIFY(panelClosedSpy.wait());
 
     // snap once more
     QCOMPARE(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), targetPoint);
 
     // and close
-    QSignalSpy windowClosedSpy(testWindow, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(testWindow, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
 }
 
 void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingWaylandPanel_data()
 {
     QTest::addColumn<QRect>("panelGeometry");
     QTest::addColumn<QPoint>("targetPoint");
     QTest::addColumn<QPoint>("expectedAdjustedPoint");
 
     QTest::newRow("top") << QRect(0, 0, 100, 20) << QPoint(50, 25) << QPoint(50, 20);
     QTest::newRow("bottom") << QRect(0, 1024-20, 100, 20) << QPoint(50, 1024 - 25 - 50) << QPoint(50, 1024 - 20 - 50);
     QTest::newRow("left") << QRect(0, 0, 20, 100) << QPoint(25, 50) << QPoint(20, 50);
     QTest::newRow("right") << QRect(1280 - 20, 0, 20, 100) << QPoint(1280 - 25 - 100, 50) << QPoint(1280 - 20 - 100, 50);
 }
 
 void MoveResizeWindowTest::testAdjustClientGeometryOfAutohidingWaylandPanel()
 {
     // this test verifies that auto hiding panels are ignored when adjusting client geometry
     // see BUG 365892
 
     // first create our panel
     using namespace KWayland::Client;
     QScopedPointer<Surface> panelSurface(Test::createSurface());
     QVERIFY(!panelSurface.isNull());
     QScopedPointer<XdgShellSurface> panelShellSurface(Test::createXdgShellStableSurface(panelSurface.data()));
     QVERIFY(!panelShellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(panelSurface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AutoHide);
     QFETCH(QRect, panelGeometry);
     plasmaSurface->setPosition(panelGeometry.topLeft());
     // let's render
     auto panel = Test::renderAndWaitForShown(panelSurface.data(), panelGeometry.size(), Qt::blue);
     QVERIFY(panel);
     QCOMPARE(panel->frameGeometry(), panelGeometry);
     QVERIFY(panel->isDock());
 
     // let's create a window
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     auto testWindow = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(testWindow);
     QVERIFY(testWindow->isMovable());
     // panel is not yet hidden, we should snap against it
     QFETCH(QPoint, targetPoint);
     QTEST(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), "expectedAdjustedPoint");
 
     // now let's hide the panel
     QSignalSpy panelHiddenSpy(panel, &AbstractClient::windowHidden);
     QVERIFY(panelHiddenSpy.isValid());
     plasmaSurface->requestHideAutoHidingPanel();
     QVERIFY(panelHiddenSpy.wait());
 
     // now try to snap again
     QCOMPARE(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), targetPoint);
 
     // and destroy the panel again
-    QSignalSpy panelClosedSpy(panel, &XdgShellClient::windowClosed);
+    QSignalSpy panelClosedSpy(panel, &AbstractClient::windowClosed);
     QVERIFY(panelClosedSpy.isValid());
     plasmaSurface.reset();
     panelShellSurface.reset();
     panelSurface.reset();
     QVERIFY(panelClosedSpy.wait());
 
     // snap once more
     QCOMPARE(Workspace::self()->adjustClientPosition(testWindow, targetPoint, false), targetPoint);
 
     // and close
-    QSignalSpy windowClosedSpy(testWindow, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(testWindow, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
 }
 
 void MoveResizeWindowTest::testResizeForVirtualKeyboard()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // let's render
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(500, 800), Qt::blue);
     QVERIFY(client);
 
     // The client should receive a configure event upon becoming active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
 
     client->move(100, 300);
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     QCOMPARE(client->frameGeometry(), QRect(100, 300, 500, 800));
     client->setVirtualKeyboardGeometry(QRect(0, 100, 1280, 500));
     QVERIFY(configureRequestedSpy.wait());
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     // render at the new size
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     QCOMPARE(client->frameGeometry(), QRect(100, 0, 500, 101));
     client->setVirtualKeyboardGeometry(QRect());
     QVERIFY(configureRequestedSpy.wait());
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     // render at the new size
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(100, 300, 500, 800));
 }
 
 void MoveResizeWindowTest::testResizeForVirtualKeyboardWithMaximize()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // let's render
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(500, 800), Qt::blue);
     QVERIFY(client);
 
     // The client should receive a configure event upon becoming active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
 
     client->move(100, 300);
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     QCOMPARE(client->frameGeometry(), QRect(100, 300, 500, 800));
     client->setVirtualKeyboardGeometry(QRect(0, 100, 1280, 500));
     QVERIFY(configureRequestedSpy.wait());
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     // render at the new size
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(100, 0, 500, 101));
 
     client->setMaximize(true, true);
     QVERIFY(configureRequestedSpy.wait());
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
 
     client->setVirtualKeyboardGeometry(QRect());
     QVERIFY(!configureRequestedSpy.wait(10));
 
     // render at the size of the configureRequested.. it won't have changed
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(!frameGeometryChangedSpy.wait(10));
 
     // Size will NOT be restored
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
 }
 
 void MoveResizeWindowTest::testResizeForVirtualKeyboardWithFullScreen()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // let's render
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(500, 800), Qt::blue);
     QVERIFY(client);
 
     // The client should receive a configure event upon becoming active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
 
     client->move(100, 300);
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     QCOMPARE(client->frameGeometry(), QRect(100, 300, 500, 800));
     client->setVirtualKeyboardGeometry(QRect(0, 100, 1280, 500));
     QVERIFY(configureRequestedSpy.wait());
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     // render at the new size
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(100, 0, 500, 101));
 
     client->setFullScreen(true, true);
     QVERIFY(configureRequestedSpy.wait());
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
 
     client->setVirtualKeyboardGeometry(QRect());
     QVERIFY(!configureRequestedSpy.wait(10));
 
     // render at the size of the configureRequested.. it won't have changed
     Test::render(surface.data(), configureRequestedSpy.last().first().toSize(), Qt::blue);
     QVERIFY(!frameGeometryChangedSpy.wait(10));
     // Size will NOT be restored
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
 }
 
 void MoveResizeWindowTest::testDestroyMoveClient()
 {
     // This test verifies that active move operation gets finished when
     // the associated client is destroyed.
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Start moving the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
     workspace()->slotWindowMove();
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(client->isMove(), true);
     QCOMPARE(client->isResize(), false);
 
     // Let's pretend that the client crashed.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
 }
 
 void MoveResizeWindowTest::testDestroyResizeClient()
 {
     // This test verifies that active resize operation gets finished when
     // the associated client is destroyed.
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Start resizing the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
     workspace()->slotWindowResize();
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), true);
 
     // Let's pretend that the client crashed.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
 }
 
 void MoveResizeWindowTest::testUnmapMoveClient()
 {
     // This test verifies that active move operation gets cancelled when
     // the associated client is unmapped.
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Start resizing the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
     workspace()->slotWindowMove();
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(client->isMove(), true);
     QCOMPARE(client->isResize(), false);
 
     // Unmap the client while we're moving it.
-    QSignalSpy hiddenSpy(client, &XdgShellClient::windowHidden);
+    QSignalSpy hiddenSpy(client, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
 }
 
 void MoveResizeWindowTest::testUnmapResizeClient()
 {
     // This test verifies that active resize operation gets cancelled when
     // the associated client is unmapped.
 
     // Create the test client.
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     // Start resizing the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
     workspace()->slotWindowResize();
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), true);
 
     // Unmap the client while we're resizing it.
-    QSignalSpy hiddenSpy(client, &XdgShellClient::windowHidden);
+    QSignalSpy hiddenSpy(client, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(client->isMove(), false);
     QCOMPARE(client->isResize(), false);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::MoveResizeWindowTest)
 #include "move_resize_window_test.moc"
diff --git a/autotests/integration/placement_test.cpp b/autotests/integration/placement_test.cpp
index 404023b30..1ec578861 100644
--- a/autotests/integration/placement_test.cpp
+++ b/autotests/integration/placement_test.cpp
@@ -1,361 +1,360 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2019 David Edmundson <davidedmundson@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "abstract_client.h"
 #include "cursor.h"
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/xdgshell.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_placement-0");
 
 struct PlaceWindowResult
 {
     QSize initiallyConfiguredSize;
     KWayland::Client::XdgShellSurface::States initiallyConfiguredStates;
     QRect finalGeometry;
 };
 
 class TestPlacement : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void init();
     void cleanup();
     void initTestCase();
 
     void testPlaceSmart();
     void testPlaceZeroCornered();
     void testPlaceMaximized();
     void testPlaceMaximizedLeavesFullscreen();
     void testPlaceCentered();
     void testPlaceUnderMouse();
     void testPlaceCascaded();
     void testPlaceRandom();
 
 private:
     void setPlacementPolicy(Placement::Policy policy);
     /*
      * Create a window with the lifespan of parent and return relevant results for testing
      * defaultSize is the buffer size to use if the compositor returns an empty size in the first configure
      * event.
      */
     PlaceWindowResult createAndPlaceWindow(const QSize &defaultSize, QObject *parent);
 };
 
 void TestPlacement::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::XdgDecoration |
                                          Test::AdditionalWaylandInterface::PlasmaShell));
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(512, 512));
 }
 
 void TestPlacement::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestPlacement::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestPlacement::setPlacementPolicy(Placement::Policy policy)
 {
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", Placement::policyToString(policy));
     group.sync();
     Workspace::self()->slotReconfigure();
 }
 
 PlaceWindowResult TestPlacement::createAndPlaceWindow(const QSize &defaultSize, QObject *parent)
 {
     PlaceWindowResult rc;
 
     // create a new window
     auto surface = Test::createSurface(parent);
     auto shellSurface = Test::createXdgShellStableSurface(surface, surface, Test::CreationSetup::CreateOnly);
     QSignalSpy configSpy(shellSurface, &XdgShellSurface::configureRequested);
     surface->commit(Surface::CommitFlag::None);
     configSpy.wait();
 
     rc.initiallyConfiguredSize = configSpy[0][0].toSize();
     rc.initiallyConfiguredStates = configSpy[0][1].value<KWayland::Client::XdgShellSurface::States>();
     shellSurface->ackConfigure(configSpy[0][2].toUInt());
 
     QSize size = rc.initiallyConfiguredSize;
 
     if (size.isEmpty()) {
         size = defaultSize;
     }
 
     auto c = Test::renderAndWaitForShown(surface, size, Qt::red);
 
     rc.finalGeometry = c->frameGeometry();
     return rc;
 }
 
 void TestPlacement::testPlaceSmart()
 {
     setPlacementPolicy(Placement::Smart);
 
     QScopedPointer<QObject> testParent(new QObject); //dumb QObject just for scoping surfaces to the test
 
     QRegion usedArea;
 
     for (int i = 0; i < 4; i++) {
         PlaceWindowResult windowPlacement = createAndPlaceWindow(QSize(600, 500), testParent.data());
         // smart placement shouldn't define a size on clients
         QCOMPARE(windowPlacement.initiallyConfiguredSize, QSize(0, 0));
         QCOMPARE(windowPlacement.finalGeometry.size(), QSize(600, 500));
 
         // exact placement isn't a defined concept that should be tested
         // but the goal of smart placement is to make sure windows don't overlap until they need to
         // 4 windows of 600, 500 should fit without overlap
         QVERIFY(!usedArea.intersects(windowPlacement.finalGeometry));
         usedArea += windowPlacement.finalGeometry;
     }
 }
 
 void TestPlacement::testPlaceZeroCornered()
 {
     setPlacementPolicy(Placement::ZeroCornered);
 
     QScopedPointer<QObject> testParent(new QObject);
 
     for (int i = 0; i < 4; i++) {
         PlaceWindowResult windowPlacement = createAndPlaceWindow(QSize(600, 500), testParent.data());
         // smart placement shouldn't define a size on clients
         QCOMPARE(windowPlacement.initiallyConfiguredSize, QSize(0, 0));
         // size should match our buffer
         QCOMPARE(windowPlacement.finalGeometry.size(), QSize(600, 500));
         //and it should be in the corner
         QCOMPARE(windowPlacement.finalGeometry.topLeft(), QPoint(0, 0));
     }
 }
 
 void TestPlacement::testPlaceMaximized()
 {
     setPlacementPolicy(Placement::Maximizing);
 
     // add a top panel
     QScopedPointer<Surface> panelSurface(Test::createSurface());
     QScopedPointer<QObject> panelShellSurface(Test::createXdgShellStableSurface(panelSurface.data()));
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(panelSurface.data()));
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPosition(QPoint(0, 0));
     Test::renderAndWaitForShown(panelSurface.data(), QSize(1280, 20), Qt::blue);
 
     QScopedPointer<QObject> testParent(new QObject);
 
     // all windows should be initially maximized with an initial configure size sent
     for (int i = 0; i < 4; i++) {
         PlaceWindowResult windowPlacement = createAndPlaceWindow(QSize(600, 500), testParent.data());
         QVERIFY(windowPlacement.initiallyConfiguredStates & XdgShellSurface::State::Maximized);
         QCOMPARE(windowPlacement.initiallyConfiguredSize, QSize(1280, 1024 - 20));
         QCOMPARE(windowPlacement.finalGeometry, QRect(0, 20, 1280, 1024 - 20)); // under the panel
     }
 }
 
 void TestPlacement::testPlaceMaximizedLeavesFullscreen()
 {
     setPlacementPolicy(Placement::Maximizing);
 
     // add a top panel
     QScopedPointer<Surface> panelSurface(Test::createSurface());
     QScopedPointer<QObject> panelShellSurface(Test::createXdgShellStableSurface(panelSurface.data()));
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(panelSurface.data()));
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPosition(QPoint(0, 0));
     Test::renderAndWaitForShown(panelSurface.data(), QSize(1280, 20), Qt::blue);
 
     QScopedPointer<QObject> testParent(new QObject);
 
     // all windows should be initially fullscreen with an initial configure size sent, despite the policy
     for (int i = 0; i < 4; i++) {
         auto surface = Test::createSurface(testParent.data());
         auto shellSurface = Test::createXdgShellStableSurface(surface, surface, Test::CreationSetup::CreateOnly);
         shellSurface->setFullscreen(true);
         QSignalSpy configSpy(shellSurface, &XdgShellSurface::configureRequested);
         surface->commit(Surface::CommitFlag::None);
         configSpy.wait();
 
         auto initiallyConfiguredSize = configSpy[0][0].toSize();
         auto initiallyConfiguredStates = configSpy[0][1].value<KWayland::Client::XdgShellSurface::States>();
         shellSurface->ackConfigure(configSpy[0][2].toUInt());
 
         auto c = Test::renderAndWaitForShown(surface, initiallyConfiguredSize, Qt::red);
 
         QVERIFY(initiallyConfiguredStates & XdgShellSurface::State::Fullscreen);
         QCOMPARE(initiallyConfiguredSize, QSize(1280, 1024 ));
         QCOMPARE(c->frameGeometry(), QRect(0, 0, 1280, 1024));
     }
 }
 
 void TestPlacement::testPlaceCentered()
 {
     // This test verifies that Centered placement policy works.
 
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", Placement::policyToString(Placement::Centered));
     group.sync();
     workspace()->slotReconfigure();
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->frameGeometry(), QRect(590, 487, 100, 50));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestPlacement::testPlaceUnderMouse()
 {
     // This test verifies that Under Mouse placement policy works.
 
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", Placement::policyToString(Placement::UnderMouse));
     group.sync();
     workspace()->slotReconfigure();
 
     KWin::Cursor::setPos(QPoint(200, 300));
     QCOMPARE(KWin::Cursor::pos(), QPoint(200, 300));
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->frameGeometry(), QRect(151, 276, 100, 50));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestPlacement::testPlaceCascaded()
 {
     // This test verifies that Cascaded placement policy works.
 
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", Placement::policyToString(Placement::Cascade));
     group.sync();
     workspace()->slotReconfigure();
 
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::red);
     QVERIFY(client1);
     QCOMPARE(client1->pos(), QPoint(0, 0));
     QCOMPARE(client1->size(), QSize(100, 50));
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QCOMPARE(client2->pos(), client1->pos() + workspace()->cascadeOffset(client2));
     QCOMPARE(client2->size(), QSize(100, 50));
 
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::green);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::green);
     QVERIFY(client3);
     QCOMPARE(client3->pos(), client2->pos() + workspace()->cascadeOffset(client3));
     QCOMPARE(client3->size(), QSize(100, 50));
 
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
 }
 
 void TestPlacement::testPlaceRandom()
 {
     // This test verifies that Random placement policy works.
 
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", Placement::policyToString(Placement::Random));
     group.sync();
     workspace()->slotReconfigure();
 
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::red);
     QVERIFY(client1);
     QCOMPARE(client1->size(), QSize(100, 50));
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client2);
     QVERIFY(client2->pos() != client1->pos());
     QCOMPARE(client2->size(), QSize(100, 50));
 
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
-    XdgShellClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::green);
+    AbstractClient *client3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::green);
     QVERIFY(client3);
     QVERIFY(client3->pos() != client1->pos());
     QVERIFY(client3->pos() != client2->pos());
     QCOMPARE(client3->size(), QSize(100, 50));
 
     shellSurface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(client3));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
 }
 
 WAYLANDTEST_MAIN(TestPlacement)
 #include "placement_test.moc"
diff --git a/autotests/integration/plasma_surface_test.cpp b/autotests/integration/plasma_surface_test.cpp
index 60aef48fc..0038008ac 100644
--- a/autotests/integration/plasma_surface_test.cpp
+++ b/autotests/integration/plasma_surface_test.cpp
@@ -1,439 +1,439 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
 #include "cursor.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 Q_DECLARE_METATYPE(KWin::Layer)
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_plasma_surface-0");
 
 class PlasmaSurfaceTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testRoleOnAllDesktops_data();
     void testRoleOnAllDesktops();
     void testAcceptsFocus_data();
     void testAcceptsFocus();
 
     void testDesktopIsOpaque();
     void testPanelWindowsCanCover_data();
     void testPanelWindowsCanCover();
     void testOSDPlacement();
     void testOSDPlacementManualPosition_data();
     void testOSDPlacementManualPosition();
     void testPanelTypeHasStrut_data();
     void testPanelTypeHasStrut();
     void testPanelActivate_data();
     void testPanelActivate();
 
 private:
     KWayland::Client::Compositor *m_compositor = nullptr;
     PlasmaShell *m_plasmaShell = nullptr;
 };
 
 void PlasmaSurfaceTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
+    qRegisterMetaType<KWin::AbstractClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
 }
 
 void PlasmaSurfaceTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::PlasmaShell));
     m_compositor = Test::waylandCompositor();
     m_plasmaShell = Test::waylandPlasmaShell();
 
     KWin::Cursor::setPos(640, 512);
 }
 
 void PlasmaSurfaceTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void PlasmaSurfaceTest::testRoleOnAllDesktops_data()
 {
     QTest::addColumn<PlasmaShellSurface::Role>("role");
     QTest::addColumn<bool>("expectedOnAllDesktops");
 
     QTest::newRow("Desktop") << PlasmaShellSurface::Role::Desktop << true;
     QTest::newRow("Panel") << PlasmaShellSurface::Role::Panel << true;
     QTest::newRow("OSD") << PlasmaShellSurface::Role::OnScreenDisplay << true;
     QTest::newRow("Normal") << PlasmaShellSurface::Role::Normal << false;
     QTest::newRow("Notification") << PlasmaShellSurface::Role::Notification << true;
     QTest::newRow("ToolTip") << PlasmaShellSurface::Role::ToolTip << true;
     QTest::newRow("CriticalNotification") << PlasmaShellSurface::Role::CriticalNotification << true;
 }
 
 void PlasmaSurfaceTest::testRoleOnAllDesktops()
 {
     // this test verifies that a XdgShellClient is set on all desktops when the role changes
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
 
     // now render to map the window
     AbstractClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
 
     // currently the role is not yet set, so the window should not be on all desktops
     QCOMPARE(c->isOnAllDesktops(), false);
 
     // now let's try to change that
     QSignalSpy onAllDesktopsSpy(c, &AbstractClient::desktopChanged);
     QVERIFY(onAllDesktopsSpy.isValid());
     QFETCH(PlasmaShellSurface::Role, role);
     plasmaSurface->setRole(role);
     QFETCH(bool, expectedOnAllDesktops);
     QCOMPARE(onAllDesktopsSpy.wait(), expectedOnAllDesktops);
     QCOMPARE(c->isOnAllDesktops(), expectedOnAllDesktops);
 
     // let's create a second window where we init a little bit different
     // first creating the PlasmaSurface then the Shell Surface
     QScopedPointer<Surface> surface2(Test::createSurface());
     QVERIFY(!surface2.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface2(m_plasmaShell->createSurface(surface2.data()));
     QVERIFY(!plasmaSurface2.isNull());
     plasmaSurface2->setRole(role);
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     QVERIFY(!shellSurface2.isNull());
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c2);
     QVERIFY(c != c2);
 
     QCOMPARE(c2->isOnAllDesktops(), expectedOnAllDesktops);
 }
 
 void PlasmaSurfaceTest::testAcceptsFocus_data()
 {
     QTest::addColumn<PlasmaShellSurface::Role>("role");
     QTest::addColumn<bool>("wantsInput");
     QTest::addColumn<bool>("active");
 
     QTest::newRow("Desktop") << PlasmaShellSurface::Role::Desktop << true << true;
     QTest::newRow("Panel") << PlasmaShellSurface::Role::Panel << true << false;
     QTest::newRow("OSD") << PlasmaShellSurface::Role::OnScreenDisplay << false << false;
     QTest::newRow("Normal") << PlasmaShellSurface::Role::Normal << true << true;
     QTest::newRow("Notification") << PlasmaShellSurface::Role::Notification << false << false;
     QTest::newRow("ToolTip") << PlasmaShellSurface::Role::ToolTip << false << false;
     QTest::newRow("CriticalNotification") << PlasmaShellSurface::Role::CriticalNotification << false << false;
 }
 
 void PlasmaSurfaceTest::testAcceptsFocus()
 {
     // this test verifies that some surface roles don't get focus
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     QFETCH(PlasmaShellSurface::Role, role);
     plasmaSurface->setRole(role);
 
     // now render to map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QTEST(c->wantsInput(), "wantsInput");
     QTEST(c->isActive(), "active");
 }
 
 void PlasmaSurfaceTest::testDesktopIsOpaque()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Desktop);
 
     // now render to map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(c->windowType(), NET::Desktop);
     QVERIFY(c->isDesktop());
 
     QVERIFY(!c->hasAlpha());
     QCOMPARE(c->depth(), 24);
 }
 
 void PlasmaSurfaceTest::testOSDPlacement()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::OnScreenDisplay);
 
     // now render and map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(c->windowType(), NET::OnScreenDisplay);
     QVERIFY(c->isOnScreenDisplay());
     QCOMPARE(c->frameGeometry(), QRect(590, 649, 100, 50));
 
     // change the screen size
     QSignalSpy screensChangedSpy(screens(), &Screens::changed);
     QVERIFY(screensChangedSpy.isValid());
     const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 2),
                               Q_ARG(QVector<QRect>, geometries));
     QVERIFY(screensChangedSpy.wait());
     QCOMPARE(screensChangedSpy.count(), 1);
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
 
     QCOMPARE(c->frameGeometry(), QRect(590, 649, 100, 50));
 
     // change size of window
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     Test::render(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(c->frameGeometry(), QRect(540, 616, 200, 100));
 }
 
 void PlasmaSurfaceTest::testOSDPlacementManualPosition_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgv6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void PlasmaSurfaceTest::testOSDPlacementManualPosition()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::OnScreenDisplay);
 
     plasmaSurface->setPosition(QPoint(50, 70));
 
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // now render and map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QVERIFY(c->isInitialPositionSet());
     QCOMPARE(c->windowType(), NET::OnScreenDisplay);
     QVERIFY(c->isOnScreenDisplay());
     QCOMPARE(c->frameGeometry(), QRect(50, 70, 100, 50));
 }
 
 
 void PlasmaSurfaceTest::testPanelTypeHasStrut_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<PlasmaShellSurface::PanelBehavior>("panelBehavior");
     QTest::addColumn<bool>("expectedStrut");
     QTest::addColumn<QRect>("expectedMaxArea");
     QTest::addColumn<KWin::Layer>("expectedLayer");
 
     QTest::newRow("always visible - xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << PlasmaShellSurface::PanelBehavior::AlwaysVisible << true << QRect(0, 50, 1280, 974) << KWin::DockLayer;
     QTest::newRow("always visible - xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable << PlasmaShellSurface::PanelBehavior::AlwaysVisible << true << QRect(0, 50, 1280, 974) << KWin::DockLayer;
     QTest::newRow("autohide - xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << PlasmaShellSurface::PanelBehavior::AutoHide << false << QRect(0, 0, 1280, 1024) << KWin::AboveLayer;
     QTest::newRow("autohide - xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable << PlasmaShellSurface::PanelBehavior::AutoHide << false << QRect(0, 0, 1280, 1024) << KWin::AboveLayer;
     QTest::newRow("windows can cover - xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << PlasmaShellSurface::PanelBehavior::WindowsCanCover << false << QRect(0, 0, 1280, 1024) << KWin::NormalLayer;
     QTest::newRow("windows can cover - xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable << PlasmaShellSurface::PanelBehavior::WindowsCanCover << false << QRect(0, 0, 1280, 1024) << KWin::NormalLayer;
     QTest::newRow("windows go below - xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << PlasmaShellSurface::PanelBehavior::WindowsGoBelow << false << QRect(0, 0, 1280, 1024) << KWin::DockLayer;
     QTest::newRow("windows go below - xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable << PlasmaShellSurface::PanelBehavior::WindowsGoBelow << false << QRect(0, 0, 1280, 1024) << KWin::DockLayer;
 }
 
 void PlasmaSurfaceTest::testPanelTypeHasStrut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<QObject> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPosition(QPoint(0, 0));
     QFETCH(PlasmaShellSurface::PanelBehavior, panelBehavior);
     plasmaSurface->setPanelBehavior(panelBehavior);
 
     // now render and map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(c->windowType(), NET::Dock);
     QVERIFY(c->isDock());
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QTEST(c->hasStrut(), "expectedStrut");
     QTEST(workspace()->clientArea(MaximizeArea, 0, 0), "expectedMaxArea");
     QTEST(c->layer(), "expectedLayer");
 }
 
 void PlasmaSurfaceTest::testPanelWindowsCanCover_data()
 {
     QTest::addColumn<QRect>("panelGeometry");
     QTest::addColumn<QRect>("windowGeometry");
     QTest::addColumn<QPoint>("triggerPoint");
 
     QTest::newRow("top-full-edge") << QRect(0, 0, 1280, 30) << QRect(0, 0, 200, 300) << QPoint(100, 0);
     QTest::newRow("top-left-edge") << QRect(0, 0, 1000, 30) << QRect(0, 0, 200, 300) << QPoint(100, 0);
     QTest::newRow("top-right-edge") << QRect(280, 0, 1000, 30) << QRect(1000, 0, 200, 300) << QPoint(1000, 0);
     QTest::newRow("bottom-full-edge") << QRect(0, 994, 1280, 30) << QRect(0, 724, 200, 300) << QPoint(100, 1023);
     QTest::newRow("bottom-left-edge") << QRect(0, 994, 1000, 30) << QRect(0, 724, 200, 300) << QPoint(100, 1023);
     QTest::newRow("bottom-right-edge") << QRect(280, 994, 1000, 30) << QRect(1000, 724, 200, 300) << QPoint(1000, 1023);
     QTest::newRow("left-full-edge") << QRect(0, 0, 30, 1024) << QRect(0, 0, 200, 300) << QPoint(0, 100);
     QTest::newRow("left-top-edge") << QRect(0, 0, 30, 800) << QRect(0, 0, 200, 300) << QPoint(0, 100);
     QTest::newRow("left-bottom-edge") << QRect(0, 200, 30, 824) << QRect(0, 0, 200, 300) << QPoint(0, 250);
     QTest::newRow("right-full-edge") << QRect(1250, 0, 30, 1024) << QRect(1080, 0, 200, 300) << QPoint(1279, 100);
     QTest::newRow("right-top-edge") << QRect(1250, 0, 30, 800) << QRect(1080, 0, 200, 300) << QPoint(1279, 100);
     QTest::newRow("right-bottom-edge") << QRect(1250, 200, 30, 824) << QRect(1080, 0, 200, 300) << QPoint(1279, 250);
 }
 
 void PlasmaSurfaceTest::testPanelWindowsCanCover()
 {
     // this test verifies the behavior of a panel with windows can cover
     // triggering the screen edge should raise the panel.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     QFETCH(QRect, panelGeometry);
     plasmaSurface->setPosition(panelGeometry.topLeft());
     plasmaSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::WindowsCanCover);
 
     // now render and map the window
     auto panel = Test::renderAndWaitForShown(surface.data(), panelGeometry.size(), Qt::blue);
 
     QVERIFY(panel);
     QCOMPARE(panel->windowType(), NET::Dock);
     QVERIFY(panel->isDock());
     QCOMPARE(panel->frameGeometry(), panelGeometry);
     QCOMPARE(panel->hasStrut(), false);
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 0), QRect(0, 0, 1280, 1024));
     QCOMPARE(panel->layer(), KWin::NormalLayer);
 
     // create a Window
     QScopedPointer<Surface> surface2(Test::createSurface());
     QVERIFY(!surface2.isNull());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     QVERIFY(!shellSurface2.isNull());
 
     QFETCH(QRect, windowGeometry);
     auto c = Test::renderAndWaitForShown(surface2.data(), windowGeometry.size(), Qt::red);
 
     QVERIFY(c);
     QCOMPARE(c->windowType(), NET::Normal);
     QVERIFY(c->isActive());
     QCOMPARE(c->layer(), KWin::NormalLayer);
     c->move(windowGeometry.topLeft());
     QCOMPARE(c->frameGeometry(), windowGeometry);
 
     auto stackingOrder = workspace()->stackingOrder();
     QCOMPARE(stackingOrder.count(), 2);
     QCOMPARE(stackingOrder.first(), panel);
     QCOMPARE(stackingOrder.last(), c);
 
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
     // trigger screenedge
     QFETCH(QPoint, triggerPoint);
     KWin::Cursor::setPos(triggerPoint);
     QCOMPARE(stackingOrderChangedSpy.count(), 1);
     stackingOrder = workspace()->stackingOrder();
     QCOMPARE(stackingOrder.count(), 2);
     QCOMPARE(stackingOrder.first(), c);
     QCOMPARE(stackingOrder.last(), panel);
 }
 
 void PlasmaSurfaceTest::testPanelActivate_data()
 {
     QTest::addColumn<bool>("wantsFocus");
     QTest::addColumn<bool>("active");
 
     QTest::newRow("no focus") << false << false;
     QTest::newRow("focus") << true << true;
 }
 
 void PlasmaSurfaceTest::testPanelActivate()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     QFETCH(bool, wantsFocus);
     plasmaSurface->setPanelTakesFocus(wantsFocus);
 
     auto panel = Test::renderAndWaitForShown(surface.data(), QSize(100, 200), Qt::blue);
 
     QVERIFY(panel);
     QCOMPARE(panel->windowType(), NET::Dock);
     QVERIFY(panel->isDock());
     QFETCH(bool, active);
     QCOMPARE(panel->dockWantsInput(), active);
     QCOMPARE(panel->isActive(), active);
 }
 
 WAYLANDTEST_MAIN(PlasmaSurfaceTest)
 #include "plasma_surface_test.moc"
diff --git a/autotests/integration/plasmawindow_test.cpp b/autotests/integration/plasmawindow_test.cpp
index 9c3984409..4b22e98f2 100644
--- a/autotests/integration/plasmawindow_test.cpp
+++ b/autotests/integration/plasmawindow_test.cpp
@@ -1,332 +1,330 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/seat_interface.h>
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <QPainter>
 #include <QRasterWindow>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWayland::Client;
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_plasma-window-0");
 
 class PlasmaWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testCreateDestroyX11PlasmaWindow();
     void testInternalWindowNoPlasmaWindow();
     void testPopupWindowNoPlasmaWindow();
     void testLockScreenNoPlasmaWindow();
     void testDestroyedButNotUnmapped();
 
 private:
     PlasmaWindowManagement *m_windowManagement = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
 };
 
 void PlasmaWindowTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     setenv("QMLSCENE_DEVICE", "softwarecontext", true);
     waylandServer()->initWorkspace();
 }
 
 void PlasmaWindowTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::WindowManagement));
     m_windowManagement = Test::waylandWindowManagement();
     m_compositor = Test::waylandCompositor();
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void PlasmaWindowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void PlasmaWindowTest::testCreateDestroyX11PlasmaWindow()
 {
     // this test verifies that a PlasmaWindow gets unmapped on Client side when an X11 client is destroyed
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // create an xcb window
     struct XcbConnectionDeleter
     {
         static inline void cleanup(xcb_connection_t *pointer)
         {
             xcb_disconnect(pointer);
         }
     };
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QVERIFY(client->isActive());
     // verify that it gets the keyboard focus
     if (!client->surface()) {
         // we don't have a surface yet, so focused keyboard surface if set is not ours
         QVERIFY(!waylandServer()->seat()->focusedKeyboardSurface());
         QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
         QVERIFY(surfaceChangedSpy.isValid());
         QVERIFY(surfaceChangedSpy.wait());
     }
     QVERIFY(client->surface());
     QCOMPARE(waylandServer()->seat()->focusedKeyboardSurface(), client->surface());
 
     // now that should also give it to us on client side
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
     QCOMPARE(m_windowManagement->windows().count(), 1);
     auto pw = m_windowManagement->windows().first();
     QCOMPARE(pw->geometry(), client->frameGeometry());
     QSignalSpy geometryChangedSpy(pw, &PlasmaWindow::geometryChanged);
     QVERIFY(geometryChangedSpy.isValid());
 
     QSignalSpy unmappedSpy(m_windowManagement->windows().first(), &PlasmaWindow::unmapped);
     QVERIFY(unmappedSpy.isValid());
     QSignalSpy destroyedSpy(m_windowManagement->windows().first(), &QObject::destroyed);
     QVERIFY(destroyedSpy.isValid());
 
     // now shade the window
     const QRect geoBeforeShade = client->frameGeometry();
     QVERIFY(geoBeforeShade.isValid());
     QVERIFY(!geoBeforeShade.isEmpty());
     workspace()->slotWindowShade();
     QVERIFY(client->isShade());
     QVERIFY(client->frameGeometry() != geoBeforeShade);
     QVERIFY(geometryChangedSpy.wait());
     QCOMPARE(pw->geometry(), client->frameGeometry());
     // and unshade again
     workspace()->slotWindowShade();
     QVERIFY(!client->isShade());
     QCOMPARE(client->frameGeometry(), geoBeforeShade);
     QVERIFY(geometryChangedSpy.wait());
     QCOMPARE(pw->geometry(), geoBeforeShade);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 
     QVERIFY(unmappedSpy.wait());
     QCOMPARE(unmappedSpy.count(), 1);
 
     QVERIFY(destroyedSpy.wait());
 }
 
 class HelperWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     HelperWindow();
     ~HelperWindow() override;
 
 protected:
     void paintEvent(QPaintEvent *event) override;
 };
 
 HelperWindow::HelperWindow()
     : QRasterWindow(nullptr)
 {
 }
 
 HelperWindow::~HelperWindow() = default;
 
 void HelperWindow::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event)
     QPainter p(this);
     p.fillRect(0, 0, width(), height(), Qt::red);
 }
 
 void PlasmaWindowTest::testInternalWindowNoPlasmaWindow()
 {
     // this test verifies that an internal window is not added as a PlasmaWindow to the client
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
 
     QVERIFY(!plasmaWindowCreatedSpy.wait());
 }
 
 void PlasmaWindowTest::testPopupWindowNoPlasmaWindow()
 {
     // this test verifies that for a popup window no PlasmaWindow is sent to the client
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // first create the parent window
     QScopedPointer<Surface> parentSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> parentShellSurface(Test::createXdgShellStableSurface(parentSurface.data()));
-    XdgShellClient *parentClient = Test::renderAndWaitForShown(parentSurface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *parentClient = Test::renderAndWaitForShown(parentSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(parentClient);
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
 
     // now let's create a popup window for it
     XdgPositioner positioner(QSize(10, 10), QRect(0, 0, 10, 10));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QScopedPointer<Surface> popupSurface(Test::createSurface());
     QScopedPointer<XdgShellPopup> popupShellSurface(Test::createXdgShellStablePopup(popupSurface.data(), parentShellSurface.data(), positioner));
-    XdgShellClient *popupClient = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::blue);
+    AbstractClient *popupClient = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::blue);
     QVERIFY(popupClient);
     QVERIFY(!plasmaWindowCreatedSpy.wait(100));
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
 
     // let's destroy the windows
     popupShellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(popupClient));
     parentShellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(parentClient));
 }
 
 void PlasmaWindowTest::testLockScreenNoPlasmaWindow()
 {
     // this test verifies that lock screen windows are not exposed to PlasmaWindow
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // this time we use a QSignalSpy on XdgShellClient as it'a a little bit more complex setup
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     // lock
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     QVERIFY(clientAddedSpy.wait());
-    QVERIFY(clientAddedSpy.first().first().value<XdgShellClient *>()->isLockScreen());
+    QVERIFY(clientAddedSpy.first().first().value<AbstractClient *>()->isLockScreen());
     // should not be sent to the client
     QVERIFY(plasmaWindowCreatedSpy.isEmpty());
     QVERIFY(!plasmaWindowCreatedSpy.wait());
 
     // fake unlock
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     QVERIFY(lockStateChangedSpy.isValid());
     const auto children = ScreenLocker::KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
     QVERIFY(lockStateChangedSpy.wait());
     QVERIFY(!waylandServer()->isScreenLocked());
 }
 
 void PlasmaWindowTest::testDestroyedButNotUnmapped()
 {
     // this test verifies that also when a ShellSurface gets destroyed without a prior unmap
     // the PlasmaWindow gets destroyed on Client side
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // first create the parent window
     QScopedPointer<Surface> parentSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> parentShellSurface(Test::createXdgShellStableSurface(parentSurface.data()));
     // map that window
     Test::render(parentSurface.data(), QSize(100, 50), Qt::blue);
     // this should create a plasma window
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
     auto window = plasmaWindowCreatedSpy.first().first().value<PlasmaWindow*>();
     QVERIFY(window);
     QSignalSpy destroyedSpy(window, &QObject::destroyed);
     QVERIFY(destroyedSpy.isValid());
 
     // now destroy without an unmap
     parentShellSurface.reset();
     parentSurface.reset();
     QVERIFY(destroyedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::PlasmaWindowTest)
 #include "plasmawindow_test.moc"
diff --git a/autotests/integration/pointer_constraints_test.cpp b/autotests/integration/pointer_constraints_test.cpp
index 177e8c856..1c521fd47 100644
--- a/autotests/integration/pointer_constraints_test.cpp
+++ b/autotests/integration/pointer_constraints_test.cpp
@@ -1,410 +1,409 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "keyboard_input.h"
 #include "platform.h"
 #include "pointer_input.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/region.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include <linux/input.h>
 
 #include <functional>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 typedef std::function<QPoint(const QRect&)> PointerFunc;
 Q_DECLARE_METATYPE(PointerFunc)
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_constraints-0");
 
 class TestPointerConstraints : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testConfinedPointer_data();
     void testConfinedPointer();
     void testLockedPointer_data();
     void testLockedPointer();
     void testCloseWindowWithLockedPointer_data();
     void testCloseWindowWithLockedPointer();
 };
 
 void TestPointerConstraints::initTestCase()
 {
     qRegisterMetaType<PointerFunc>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // set custom config which disables the OnScreenNotification
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup group = config->group("OnScreenNotification");
     group.writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
     group.sync();
 
     kwinApp()->setConfig(config);
 
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestPointerConstraints::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::PointerConstraints));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestPointerConstraints::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestPointerConstraints::testConfinedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<PointerFunc>("positionFunction");
     QTest::addColumn<int>("xOffset");
     QTest::addColumn<int>("yOffset");
     PointerFunc bottomLeft = &QRect::bottomLeft;
     PointerFunc bottomRight = &QRect::bottomRight;
     PointerFunc topRight = &QRect::topRight;
     PointerFunc topLeft = &QRect::topLeft;
 
     QTest::newRow("XdgShellV6 - bottomLeft")  << Test::XdgShellSurfaceType::XdgShellV6 << bottomLeft  << -1 << 1;
     QTest::newRow("XdgShellV6 - bottomRight") << Test::XdgShellSurfaceType::XdgShellV6 << bottomRight << 1  << 1;
     QTest::newRow("XdgShellV6 - topLeft")     << Test::XdgShellSurfaceType::XdgShellV6 << topLeft  << -1 << -1;
     QTest::newRow("XdgShellV6 - topRight")    << Test::XdgShellSurfaceType::XdgShellV6 << topRight << 1  << -1;
     QTest::newRow("XdgWmBase - bottomLeft")   << Test::XdgShellSurfaceType::XdgShellStable << bottomLeft  << -1 << 1;
     QTest::newRow("XdgWmBase - bottomRight")  << Test::XdgShellSurfaceType::XdgShellStable << bottomRight << 1  << 1;
     QTest::newRow("XdgWmBase - topLeft")      << Test::XdgShellSurfaceType::XdgShellStable << topLeft  << -1 << -1;
     QTest::newRow("XdgWmBase - topRight")     << Test::XdgShellSurfaceType::XdgShellStable << topRight << 1  << -1;
 }
 
 void TestPointerConstraints::testConfinedPointer()
 {
     // this test sets up a Surface with a confined pointer
     // simple interaction test to verify that the pointer gets confined
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<ConfinedPointer> confinedPointer(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy confinedSpy(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy.isValid());
     QSignalSpy unconfinedSpy(confinedPointer.data(), &ConfinedPointer::unconfined);
     QVERIFY(unconfinedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     if (c->pos() == QPoint(0, 0)) {
         c->move(QPoint(1, 1));
     }
     QVERIFY(!c->frameGeometry().contains(KWin::Cursor::pos()));
 
     // now let's confine
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursor::setPos(c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(confinedSpy.wait());
 
     // picking a position outside the window geometry should not move pointer
     QSignalSpy pointerPositionChangedSpy(input(), &InputRedirection::globalPointerChanged);
     QVERIFY(pointerPositionChangedSpy.isValid());
     KWin::Cursor::setPos(QPoint(1280, 512));
     QVERIFY(pointerPositionChangedSpy.isEmpty());
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center());
 
     // TODO: test relative motion
     QFETCH(PointerFunc, positionFunction);
     const QPoint position = positionFunction(c->frameGeometry());
     KWin::Cursor::setPos(position);
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursor::pos(), position);
     // moving one to right should not be possible
     QFETCH(int, xOffset);
     KWin::Cursor::setPos(position + QPoint(xOffset, 0));
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursor::pos(), position);
     // moving one to bottom should not be possible
     QFETCH(int, yOffset);
     KWin::Cursor::setPos(position + QPoint(0, yOffset));
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursor::pos(), position);
 
     // modifier + click should be ignored
     // first ensure the settings are ok
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", QStringLiteral("Alt"));
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(!c->isMove());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 
     // set the opacity to 0.5
     c->setOpacity(0.5);
     QCOMPARE(c->opacity(), 0.5);
 
     // pointer is confined so shortcut should not work
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(c->opacity(), 0.5);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(c->opacity(), 0.5);
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 
     // deactivate the client, this should unconfine
     workspace()->activateClient(nullptr);
     QVERIFY(unconfinedSpy.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
 
     // reconfine pointer (this time with persistent life time)
     confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy confinedSpy2(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy2.isValid());
     QSignalSpy unconfinedSpy2(confinedPointer.data(), &ConfinedPointer::unconfined);
     QVERIFY(unconfinedSpy2.isValid());
 
     // activate it again, this confines again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // deactivate the client one more time with the persistent life time constraint, this should unconfine
     workspace()->activateClient(nullptr);
     QVERIFY(unconfinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
     // activate it again, this confines again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // create a second window and move it above our constrained window
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellSurface(type, surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(c2);
     QVERIFY(unconfinedSpy2.wait());
     // and unmapping the second window should confine again
     shellSurface2.reset();
     surface2.reset();
     QVERIFY(confinedSpy2.wait());
 
     // let's set a region which results in unconfined
     auto r = Test::waylandCompositor()->createRegion(QRegion(2, 2, 3, 3));
     confinedPointer->setRegion(r.get());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(unconfinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
     // and set a full region again, that should confine
     confinedPointer->setRegion(nullptr);
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // delete pointer confine
     confinedPointer.reset(nullptr);
     Test::flushWaylandConnection();
 
     QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
     QVERIFY(constraintsChangedSpy.isValid());
     QVERIFY(constraintsChangedSpy.wait());
 
     // should be unconfined
     QCOMPARE(input()->pointer()->isConstrained(), false);
 
     // confine again
     confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy confinedSpy3(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy3.isValid());
     QVERIFY(confinedSpy3.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // and now unmap
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QCOMPARE(input()->pointer()->isConstrained(), false);
 }
 
 void TestPointerConstraints::testLockedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestPointerConstraints::testLockedPointer()
 {
     // this test sets up a Surface with a locked pointer
     // simple interaction test to verify that the pointer gets locked
     // the various ways to unlock are not tested as that's already verified by testConfinedPointer
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy.isValid());
     QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
     QVERIFY(unlockedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->frameGeometry().contains(KWin::Cursor::pos()));
 
     // now let's lock
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursor::setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(lockedSpy.wait());
 
     // try to move the pointer
     // TODO: add relative pointer
     KWin::Cursor::setPos(c->frameGeometry().center() + QPoint(1, 1));
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center());
 
     // deactivate the client, this should unlock
     workspace()->activateClient(nullptr);
     QCOMPARE(input()->pointer()->isConstrained(), false);
     QVERIFY(unlockedSpy.wait());
 
     // moving cursor should be allowed again
     KWin::Cursor::setPos(c->frameGeometry().center() + QPoint(1, 1));
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center() + QPoint(1, 1));
 
     lockedPointer.reset(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy lockedSpy2(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy2.isValid());
 
     // activate the client again, this should lock again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(lockedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // try to move the pointer
     QCOMPARE(input()->pointer()->isConstrained(), true);
     KWin::Cursor::setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center() + QPoint(1, 1));
 
     // delete pointer lock
     lockedPointer.reset(nullptr);
     Test::flushWaylandConnection();
 
     QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
     QVERIFY(constraintsChangedSpy.isValid());
     QVERIFY(constraintsChangedSpy.wait());
 
     // moving cursor should be allowed again
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursor::setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center());
 }
 
 void TestPointerConstraints::testCloseWindowWithLockedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("XdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("XdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestPointerConstraints::testCloseWindowWithLockedPointer()
 {
     // test case which verifies that the pointer gets unlocked when the window for it gets closed
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy.isValid());
     QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
     QVERIFY(unlockedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->frameGeometry().contains(KWin::Cursor::pos()));
 
     // now let's lock
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursor::setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursor::pos(), c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(lockedSpy.wait());
 
     // close the window
     shellSurface.reset();
     surface.reset();
     // this should result in unlocked
     QVERIFY(unlockedSpy.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
 }
 
 WAYLANDTEST_MAIN(TestPointerConstraints)
 #include "pointer_constraints_test.moc"
diff --git a/autotests/integration/pointer_input.cpp b/autotests/integration/pointer_input.cpp
index e0c03e19e..36a1eee30 100644
--- a/autotests/integration/pointer_input.cpp
+++ b/autotests/integration/pointer_input.cpp
@@ -1,1633 +1,1631 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "effects.h"
 #include "pointer_input.h"
 #include "options.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_cursor_theme.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/clientconnection.h>
 #include <KWayland/Server/seat_interface.h>
 
 #include <wayland-cursor.h>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 template <typename T>
 PlatformCursorImage loadReferenceThemeCursor(const T &shape)
 {
     if (!waylandServer()->internalShmPool()) {
         return PlatformCursorImage();
     }
 
     QScopedPointer<WaylandCursorTheme> cursorTheme;
     cursorTheme.reset(new WaylandCursorTheme(waylandServer()->internalShmPool()));
 
     wl_cursor_image *cursor = cursorTheme->get(shape);
     if (!cursor) {
         return PlatformCursorImage();
     }
 
     wl_buffer *b = wl_cursor_image_get_buffer(cursor);
     if (!b) {
         return PlatformCursorImage();
     }
 
     waylandServer()->internalClientConection()->flush();
     waylandServer()->dispatch();
 
     auto buffer = KWayland::Server::BufferInterface::get(
         waylandServer()->internalConnection()->getResource(
             KWayland::Client::Buffer::getId(b)));
     if (!buffer) {
         return PlatformCursorImage{};
     }
 
     const qreal scale = screens()->maxScale();
     QImage image = buffer->data().copy();
     image.setDevicePixelRatio(scale);
 
     const QPoint hotSpot(
         qRound(cursor->hotspot_x / scale),
         qRound(cursor->hotspot_y / scale)
     );
 
     return PlatformCursorImage(image, hotSpot);
 }
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_input-0");
 
 class PointerInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testWarpingUpdatesFocus();
     void testWarpingGeneratesPointerMotion();
     void testWarpingDuringFilter();
     void testUpdateFocusAfterScreenChange();
     void testModifierClickUnrestrictedMove_data();
     void testModifierClickUnrestrictedMove();
     void testModifierClickUnrestrictedMoveGlobalShortcutsDisabled();
     void testModifierScrollOpacity_data();
     void testModifierScrollOpacity();
     void testModifierScrollOpacityGlobalShortcutsDisabled();
     void testScrollAction();
     void testFocusFollowsMouse();
     void testMouseActionInactiveWindow_data();
     void testMouseActionInactiveWindow();
     void testMouseActionActiveWindow_data();
     void testMouseActionActiveWindow();
     void testCursorImage();
     void testEffectOverrideCursorImage();
     void testPopup();
     void testDecoCancelsPopup();
     void testWindowUnderCursorWhileButtonPressed();
     void testConfineToScreenGeometry_data();
     void testConfineToScreenGeometry();
     void testResizeCursor_data();
     void testResizeCursor();
     void testMoveCursor();
     void testHideShowCursor();
 
 private:
     void render(KWayland::Client::Surface *surface, const QSize &size = QSize(100, 50));
     KWayland::Client::Compositor *m_compositor = nullptr;
     KWayland::Client::Seat *m_seat = nullptr;
 };
 
 void PointerInputTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void PointerInputTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::Decoration));
     QVERIFY(Test::waitForWaylandPointer());
     m_compositor = Test::waylandCompositor();
     m_seat = Test::waylandSeat();
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void PointerInputTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void PointerInputTest::render(KWayland::Client::Surface *surface, const QSize &size)
 {
     Test::render(surface, size, Qt::blue);
     Test::flushWaylandConnection();
 }
 
 void PointerInputTest::testWarpingUpdatesFocus()
 {
     // this test verifies that warping the pointer creates pointer enter and leave events
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and leave signals
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // currently there should not be a focused pointer surface
     QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
     QVERIFY(!pointer->enteredSurface());
 
     // enter
     Cursor::setPos(QPoint(25, 25));
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
     // window should have focus
     QCOMPARE(pointer->enteredSurface(), surface);
     // also on the server
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window->surface());
 
     // and out again
     Cursor::setPos(QPoint(250, 250));;
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     // there should not be a focused pointer surface anymore
     QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
     QVERIFY(!pointer->enteredSurface());
 }
 
 void PointerInputTest::testWarpingGeneratesPointerMotion()
 {
     // this test verifies that warping the pointer creates pointer motion events
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and motion
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy movedSpy(pointer, &Pointer::motion);
     QVERIFY(movedSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // enter
     kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
 
     // now warp
     Cursor::setPos(QPoint(26, 26));
     QVERIFY(movedSpy.wait());
     QCOMPARE(movedSpy.count(), 1);
     QCOMPARE(movedSpy.last().first().toPointF(), QPointF(26, 26));
 }
 
 void PointerInputTest::testWarpingDuringFilter()
 {
     // this test verifies that pointer motion is handled correctly if
     // the pointer gets warped during processing of input events
     using namespace KWayland::Client;
 
     // create pointer
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy movedSpy(pointer, &Pointer::motion);
     QVERIFY(movedSpy.isValid());
 
     // warp cursor into expected geometry
     Cursor::setPos(10, 10);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     QCOMPARE(window->pos(), QPoint(0, 0));
     QVERIFY(window->frameGeometry().contains(Cursor::pos()));
 
     // is PresentWindows effect for top left screen edge loaded
     QVERIFY(static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded("presentwindows"));
     QVERIFY(movedSpy.isEmpty());
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerMotion(QPoint(0, 0), timestamp++);
     // screen edges push back
     QCOMPARE(Cursor::pos(), QPoint(1, 1));
     QVERIFY(movedSpy.wait());
     QCOMPARE(movedSpy.count(), 2);
     QCOMPARE(movedSpy.at(0).first().toPoint(), QPoint(0, 0));
     QCOMPARE(movedSpy.at(1).first().toPoint(), QPoint(1, 1));
 }
 
 void PointerInputTest::testUpdateFocusAfterScreenChange()
 {
     // this test verifies that a pointer enter event is generated when the cursor changes to another
     // screen due to removal of screen
     using namespace KWayland::Client;
     // ensure cursor is on second screen
     Cursor::setPos(1500, 300);
 
     // create pointer and signal spy for enter and motion
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface, QSize(1280, 1024));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QVERIFY(!window->frameGeometry().contains(Cursor::pos()));
 
     QSignalSpy screensChangedSpy(screens(), &Screens::changed);
     QVERIFY(screensChangedSpy.isValid());
     // now let's remove the screen containing the cursor
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 1),
                               Q_ARG(QVector<QRect>, QVector<QRect>{QRect(0, 0, 1280, 1024)}));
     QVERIFY(screensChangedSpy.wait());
     QCOMPARE(screens()->count(), 1);
 
     // this should have warped the cursor
     QCOMPARE(Cursor::pos(), QPoint(639, 511));
     QVERIFY(window->frameGeometry().contains(Cursor::pos()));
 
     // and we should get an enter event
     QTRY_COMPARE(enteredSpy.count(), 1);
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMove_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<int>("mouseButton");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     QTest::newRow("Left Alt + Left Click")    << KEY_LEFTALT  << BTN_LEFT   << alt << false;
     QTest::newRow("Left Alt + Right Click")   << KEY_LEFTALT  << BTN_RIGHT  << alt << false;
     QTest::newRow("Left Alt + Middle Click")  << KEY_LEFTALT  << BTN_MIDDLE << alt << false;
     QTest::newRow("Right Alt + Left Click")   << KEY_RIGHTALT << BTN_LEFT   << alt << false;
     QTest::newRow("Right Alt + Right Click")  << KEY_RIGHTALT << BTN_RIGHT  << alt << false;
     QTest::newRow("Right Alt + Middle Click") << KEY_RIGHTALT << BTN_MIDDLE << alt << false;
     // now everything with meta
     QTest::newRow("Left Meta + Left Click")    << KEY_LEFTMETA  << BTN_LEFT   << meta << false;
     QTest::newRow("Left Meta + Right Click")   << KEY_LEFTMETA  << BTN_RIGHT  << meta << false;
     QTest::newRow("Left Meta + Middle Click")  << KEY_LEFTMETA  << BTN_MIDDLE << meta << false;
     QTest::newRow("Right Meta + Left Click")   << KEY_RIGHTMETA << BTN_LEFT   << meta << false;
     QTest::newRow("Right Meta + Right Click")  << KEY_RIGHTMETA << BTN_RIGHT  << meta << false;
     QTest::newRow("Right Meta + Middle Click") << KEY_RIGHTMETA << BTN_MIDDLE << meta << false;
 
     // and with capslock
     QTest::newRow("Left Alt + Left Click/CapsLock")    << KEY_LEFTALT  << BTN_LEFT   << alt << true;
     QTest::newRow("Left Alt + Right Click/CapsLock")   << KEY_LEFTALT  << BTN_RIGHT  << alt << true;
     QTest::newRow("Left Alt + Middle Click/CapsLock")  << KEY_LEFTALT  << BTN_MIDDLE << alt << true;
     QTest::newRow("Right Alt + Left Click/CapsLock")   << KEY_RIGHTALT << BTN_LEFT   << alt << true;
     QTest::newRow("Right Alt + Right Click/CapsLock")  << KEY_RIGHTALT << BTN_RIGHT  << alt << true;
     QTest::newRow("Right Alt + Middle Click/CapsLock") << KEY_RIGHTALT << BTN_MIDDLE << alt << true;
     // now everything with meta
     QTest::newRow("Left Meta + Left Click/CapsLock")    << KEY_LEFTMETA  << BTN_LEFT   << meta << true;
     QTest::newRow("Left Meta + Right Click/CapsLock")   << KEY_LEFTMETA  << BTN_RIGHT  << meta << true;
     QTest::newRow("Left Meta + Middle Click/CapsLock")  << KEY_LEFTMETA  << BTN_MIDDLE << meta << true;
     QTest::newRow("Right Meta + Left Click/CapsLock")   << KEY_RIGHTMETA << BTN_LEFT   << meta << true;
     QTest::newRow("Right Meta + Right Click/CapsLock")  << KEY_RIGHTMETA << BTN_RIGHT  << meta << true;
     QTest::newRow("Right Meta + Middle Click/CapsLock") << KEY_RIGHTMETA << BTN_MIDDLE << meta << true;
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMove()
 {
     // this test ensures that Alt+mouse button press triggers unrestricted move
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), modKey == QStringLiteral("Alt") ? Qt::AltModifier : Qt::MetaModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor on window
     Cursor::setPos(window->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     QFETCH(int, mouseButton);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonPressed(mouseButton, timestamp++);
     QVERIFY(window->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     QVERIFY(window->isMove());
     // but releasing the key should end move/resize
     kwinApp()->platform()->pointerButtonReleased(mouseButton, timestamp++);
     QVERIFY(!window->isMove());
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 
     // all of that should not have triggered button events on the surface
     QCOMPARE(buttonSpy.count(), 0);
     // also waiting shouldn't give us the event
     QVERIFY(!buttonSpy.wait(100));
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMoveGlobalShortcutsDisabled()
 {
     // this test ensures that Alt+mouse button press triggers unrestricted move
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // disable global shortcuts
     QVERIFY(!workspace()->globalShortcutsDisabled());
     workspace()->disableGlobalShortcutsForClient(true);
     QVERIFY(workspace()->globalShortcutsDisabled());
 
     // move cursor on window
     Cursor::setPos(window->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(!window->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 
     workspace()->disableGlobalShortcutsForClient(false);
 }
 
 void PointerInputTest::testModifierScrollOpacity_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     QTest::newRow("Left Alt")   << KEY_LEFTALT  << alt << false;
     QTest::newRow("Right Alt")  << KEY_RIGHTALT << alt << false;
     QTest::newRow("Left Meta")  << KEY_LEFTMETA  << meta << false;
     QTest::newRow("Right Meta") << KEY_RIGHTMETA << meta << false;
     QTest::newRow("Left Alt/CapsLock")   << KEY_LEFTALT  << alt << true;
     QTest::newRow("Right Alt/CapsLock")  << KEY_RIGHTALT << alt << true;
     QTest::newRow("Left Meta/CapsLock")  << KEY_LEFTMETA  << meta << true;
     QTest::newRow("Right Meta/CapsLock") << KEY_RIGHTMETA << meta << true;
 }
 
 void PointerInputTest::testModifierScrollOpacity()
 {
     // this test verifies that mod+wheel performs a window operation and does not
     // pass the wheel to the window
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     // set the opacity to 0.5
     window->setOpacity(0.5);
     QCOMPARE(window->opacity(), 0.5);
 
     // move cursor on window
     Cursor::setPos(window->frameGeometry().center());
 
     // simulate modifier+wheel
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(window->opacity(), 0.6);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 
     // axis should have been filtered out
     QCOMPARE(axisSpy.count(), 0);
     QVERIFY(!axisSpy.wait(100));
 }
 
 void PointerInputTest::testModifierScrollOpacityGlobalShortcutsDisabled()
 {
     // this test verifies that mod+wheel performs a window operation and does not
     // pass the wheel to the window
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     // set the opacity to 0.5
     window->setOpacity(0.5);
     QCOMPARE(window->opacity(), 0.5);
 
     // move cursor on window
     Cursor::setPos(window->frameGeometry().center());
 
     // disable global shortcuts
     QVERIFY(!workspace()->globalShortcutsDisabled());
     workspace()->disableGlobalShortcutsForClient(true);
     QVERIFY(workspace()->globalShortcutsDisabled());
 
     // simulate modifier+wheel
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 
     workspace()->disableGlobalShortcutsForClient(false);
 }
 
 void  PointerInputTest::testScrollAction()
 {
     // this test verifies that scroll on inactive window performs a mouse action
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandWindowWheel", "activate and scroll");
     group.sync();
     workspace()->slotReconfigure();
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
 
     // move cursor to the inactive window
     Cursor::setPos(window1->frameGeometry().center());
 
     quint32 timestamp = 1;
     QVERIFY(!window1->isActive());
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QVERIFY(window1->isActive());
 
     // but also the wheel event should be passed to the window
     QVERIFY(axisSpy.wait());
 
     // we need to wait a little bit, otherwise the test crashes in effectshandler, needs fixing
     QTest::qWait(100);
 }
 
 void PointerInputTest::testFocusFollowsMouse()
 {
     using namespace KWayland::Client;
     // need to create a pointer, otherwise it doesn't accept focus
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     // move cursor out of the way of first window to be created
     Cursor::setPos(900, 900);
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("AutoRaise", true);
     group.writeEntry("AutoRaiseInterval", 20);
     group.writeEntry("DelayFocusInterval", 200);
     group.writeEntry("FocusPolicy", "FocusFollowsMouse");
     group.sync();
     workspace()->slotReconfigure();
     // verify the settings
     QCOMPARE(options->focusPolicy(), Options::FocusFollowsMouse);
     QVERIFY(options->isAutoRaise());
     QCOMPARE(options->autoRaiseInterval(), 20);
     QCOMPARE(options->delayFocusInterval(), 200);
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
 
     // signal spies for active window changed and stacking order changed
     QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
     QVERIFY(activeWindowChangedSpy.isValid());
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     QVERIFY(!window1->isActive());
     QVERIFY(window2->isActive());
 
     // move on top of first window
     QVERIFY(window1->frameGeometry().contains(10, 10));
     QVERIFY(!window2->frameGeometry().contains(10, 10));
     Cursor::setPos(10, 10);
     QVERIFY(stackingOrderChangedSpy.wait());
     QCOMPARE(stackingOrderChangedSpy.count(), 1);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     QTRY_VERIFY(window1->isActive());
 
     // move on second window, but move away before active window change delay hits
     Cursor::setPos(810, 810);
     QVERIFY(stackingOrderChangedSpy.wait());
     QCOMPARE(stackingOrderChangedSpy.count(), 2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     Cursor::setPos(10, 10);
     QVERIFY(!activeWindowChangedSpy.wait(250));
     QVERIFY(window1->isActive());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     // as we moved back on window 1 that should been raised in the mean time
     QCOMPARE(stackingOrderChangedSpy.count(), 3);
 
     // quickly move on window 2 and back on window 1 should not raise window 2
     Cursor::setPos(810, 810);
     Cursor::setPos(10, 10);
     QVERIFY(!stackingOrderChangedSpy.wait(250));
 }
 
 void PointerInputTest::testMouseActionInactiveWindow_data()
 {
     QTest::addColumn<quint32>("button");
 
     QTest::newRow("Left")   << quint32(BTN_LEFT);
     QTest::newRow("Middle") << quint32(BTN_MIDDLE);
     QTest::newRow("Right")  << quint32(BTN_RIGHT);
 }
 
 void PointerInputTest::testMouseActionInactiveWindow()
 {
     // this test performs the mouse button window action on an inactive window
     // it should activate the window and raise it
     using namespace KWayland::Client;
 
     // first modify the config for this run - disable FocusFollowsMouse
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("FocusPolicy", "ClickToFocus");
     group.sync();
     group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandWindow1", "Activate, raise and pass click");
     group.writeEntry("CommandWindow2", "Activate, raise and pass click");
     group.writeEntry("CommandWindow3", "Activate, raise and pass click");
     group.sync();
     workspace()->slotReconfigure();
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
 
     // signal spies for active window changed and stacking order changed
     QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
     QVERIFY(activeWindowChangedSpy.isValid());
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     QVERIFY(!window1->isActive());
     QVERIFY(window2->isActive());
 
     // move on top of first window
     QVERIFY(window1->frameGeometry().contains(10, 10));
     QVERIFY(!window2->frameGeometry().contains(10, 10));
     Cursor::setPos(10, 10);
     // no focus follows mouse
     QVERIFY(!stackingOrderChangedSpy.wait(200));
     QVERIFY(stackingOrderChangedSpy.isEmpty());
     QVERIFY(activeWindowChangedSpy.isEmpty());
     QVERIFY(window2->isActive());
     // and click
     quint32 timestamp = 1;
     QFETCH(quint32, button);
     kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
     // should raise window1 and activate it
     QCOMPARE(stackingOrderChangedSpy.count(), 1);
     QVERIFY(!activeWindowChangedSpy.isEmpty());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     QVERIFY(window1->isActive());
     QVERIFY(!window2->isActive());
 
     // release again
     kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
 }
 
 void PointerInputTest::testMouseActionActiveWindow_data()
 {
     QTest::addColumn<bool>("clickRaise");
     QTest::addColumn<quint32>("button");
 
     for (quint32 i=BTN_LEFT; i < BTN_JOYSTICK; i++) {
         QByteArray number = QByteArray::number(i, 16);
         QTest::newRow(QByteArrayLiteral("click raise/").append(number).constData()) << true << i;
         QTest::newRow(QByteArrayLiteral("no click raise/").append(number).constData()) << false << i;
     }
 }
 
 void PointerInputTest::testMouseActionActiveWindow()
 {
     // this test verifies the mouse action performed on an active window
     // for all buttons it should trigger a window raise depending on the
     // click raise option
     using namespace KWayland::Client;
     // create a button spy - all clicks should be passed through
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // adjust config for this run
     QFETCH(bool, clickRaise);
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("ClickRaise", clickRaise);
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->isClickRaise(), clickRaise);
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     QSignalSpy window1DestroyedSpy(window1, &QObject::destroyed);
     QVERIFY(window1DestroyedSpy.isValid());
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QSignalSpy window2DestroyedSpy(window2, &QObject::destroyed);
     QVERIFY(window2DestroyedSpy.isValid());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
     // lower the currently active window
     workspace()->lowerClient(window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
 
     // signal spy for stacking order spy
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     // move on top of second window
     QVERIFY(!window1->frameGeometry().contains(900, 900));
     QVERIFY(window2->frameGeometry().contains(900, 900));
     Cursor::setPos(900, 900);
 
     // and click
     quint32 timestamp = 1;
     QFETCH(quint32, button);
     kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
     QVERIFY(buttonSpy.wait());
     if (clickRaise) {
         QCOMPARE(stackingOrderChangedSpy.count(), 1);
         QTRY_COMPARE_WITH_TIMEOUT(workspace()->topClientOnDesktop(1, -1), window2, 200);
     } else {
         QCOMPARE(stackingOrderChangedSpy.count(), 0);
         QVERIFY(!stackingOrderChangedSpy.wait(100));
         QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     }
 
     // release again
     kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
 
     delete surface1;
     QVERIFY(window1DestroyedSpy.wait());
     delete surface2;
     QVERIFY(window2DestroyedSpy.wait());
 }
 
 void PointerInputTest::testCursorImage()
 {
     // this test verifies that the pointer image gets updated correctly from the client provided data
     using namespace KWayland::Client;
     // we need a pointer to get the enter event
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     // move cursor somewhere the new window won't open
     Cursor::setPos(800, 800);
     auto p = input()->pointer();
     // at the moment it should be the fallback cursor
     const QImage fallbackCursor = p->cursorImage();
     QVERIFY(!fallbackCursor.isNull());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor to center of window, this should first set a null pointer, so we still show old cursor
     Cursor::setPos(window->frameGeometry().center());
     QCOMPARE(p->focus().data(), window);
     QCOMPARE(p->cursorImage(), fallbackCursor);
     QVERIFY(enteredSpy.wait());
 
     // create a cursor on the pointer
     Surface *cursorSurface = Test::createSurface(m_compositor);
     QVERIFY(cursorSurface);
     QSignalSpy cursorRenderedSpy(cursorSurface, &Surface::frameRendered);
     QVERIFY(cursorRenderedSpy.isValid());
     QImage red = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
     red.fill(Qt::red);
     cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(red));
     cursorSurface->damage(QRect(0, 0, 10, 10));
     cursorSurface->commit();
     pointer->setCursor(cursorSurface, QPoint(5, 5));
     QVERIFY(cursorRenderedSpy.wait());
     QCOMPARE(p->cursorImage(), red);
     QCOMPARE(p->cursorHotSpot(), QPoint(5, 5));
     // change hotspot
     pointer->setCursor(cursorSurface, QPoint(6, 6));
     Test::flushWaylandConnection();
     QTRY_COMPARE(p->cursorHotSpot(), QPoint(6, 6));
     QCOMPARE(p->cursorImage(), red);
 
     // change the buffer
     QImage blue = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
     blue.fill(Qt::blue);
     auto b = Test::waylandShmPool()->createBuffer(blue);
     cursorSurface->attachBuffer(b);
     cursorSurface->damage(QRect(0, 0, 10, 10));
     cursorSurface->commit();
     QVERIFY(cursorRenderedSpy.wait());
     QTRY_COMPARE(p->cursorImage(), blue);
     QCOMPARE(p->cursorHotSpot(), QPoint(6, 6));
 
     // scaled cursor
     QImage blueScaled = QImage(QSize(20, 20), QImage::Format_ARGB32_Premultiplied);
     blueScaled.setDevicePixelRatio(2);
     blueScaled.fill(Qt::blue);
     auto bs = Test::waylandShmPool()->createBuffer(blueScaled);
     cursorSurface->attachBuffer(bs);
     cursorSurface->setScale(2);
     cursorSurface->damage(QRect(0, 0, 20, 20));
     cursorSurface->commit();
     QVERIFY(cursorRenderedSpy.wait());
     QTRY_COMPARE(p->cursorImage(), blueScaled);
     QCOMPARE(p->cursorHotSpot(), QPoint(6, 6)); //surface-local (so not changed)
 
     // hide the cursor
     pointer->setCursor(nullptr);
     Test::flushWaylandConnection();
     QTRY_VERIFY(p->cursorImage().isNull());
 
     // move cursor somewhere else, should reset to fallback cursor
     Cursor::setPos(window->frameGeometry().bottomLeft() + QPoint(20, 20));
     QVERIFY(p->focus().isNull());
     QVERIFY(!p->cursorImage().isNull());
     QCOMPARE(p->cursorImage(), fallbackCursor);
 }
 
 class HelperEffect : public Effect
 {
     Q_OBJECT
 public:
     HelperEffect() {}
     ~HelperEffect() override {}
 };
 
 void PointerInputTest::testEffectOverrideCursorImage()
 {
     // this test verifies the effect cursor override handling
     using namespace KWayland::Client;
     // we need a pointer to get the enter event and set a cursor
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     // move cursor somewhere the new window won't open
     Cursor::setPos(800, 800);
     auto p = input()->pointer();
     // here we should have the fallback cursor
     const QImage fallback = p->cursorImage();
     QVERIFY(!fallback.isNull());
 
     // now let's create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // and move cursor to the window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursor::setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // cursor image should still be fallback
     QCOMPARE(p->cursorImage(), fallback);
 
     // now create an effect and set an override cursor
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
     const QImage sizeAll = p->cursorImage();
     QVERIFY(!sizeAll.isNull());
     QVERIFY(sizeAll != fallback);
     QVERIFY(leftSpy.wait());
 
     // let's change to arrow cursor, this should be our fallback
     effects->defineCursor(Qt::ArrowCursor);
     QCOMPARE(p->cursorImage(), fallback);
 
     // back to size all
     effects->defineCursor(Qt::SizeAllCursor);
     QCOMPARE(p->cursorImage(), sizeAll);
 
     // move cursor outside the window area
     Cursor::setPos(800, 800);
     // and end the override, which should switch to fallback
     effects->stopMouseInterception(effect.data());
     QCOMPARE(p->cursorImage(), fallback);
 
     // start mouse interception again
     effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
     QCOMPARE(p->cursorImage(), sizeAll);
 
     // move cursor to area of window
     Cursor::setPos(window->frameGeometry().center());
     // this should not result in an enter event
     QVERIFY(!enteredSpy.wait(100));
 
     // after ending the interception we should get an enter event
     effects->stopMouseInterception(effect.data());
     QVERIFY(enteredSpy.wait());
     QVERIFY(p->cursorImage().isNull());
 }
 
 void PointerInputTest::testPopup()
 {
     // this test validates the basic popup behavior
     // a button press outside the window should dismiss the popup
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonStateChangedSpy.isValid());
     QSignalSpy motionSpy(pointer, &Pointer::motion);
     QVERIFY(motionSpy.isValid());
 
     Cursor::setPos(800, 800);
 
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QCOMPARE(window->hasPopupGrab(), false);
     // move pointer into window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursor::setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window to create serial
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(buttonStateChangedSpy.wait());
 
     // now create the popup surface
     XdgPositioner positioner(QSize(100, 50), QRect(0, 0, 80, 20));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     QSignalSpy popupDoneSpy(popupShellSurface, &XdgShellPopup::popupDone);
     QVERIFY(popupDoneSpy.isValid());
     popupShellSurface->requestGrab(Test::waylandSeat(), 0); // FIXME: Serial.
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
-    auto popupClient = clientAddedSpy.last().first().value<XdgShellClient *>();
+    auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QCOMPARE(window, workspace()->activeClient());
     QCOMPARE(popupClient->transientFor(), window);
     QCOMPARE(popupClient->pos(), window->pos() + QPoint(80, 20));
     QCOMPARE(popupClient->hasPopupGrab(), true);
 
     // let's move the pointer into the center of the window
     Cursor::setPos(popupClient->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(pointer->enteredSurface(), popupSurface);
 
     // let's move the pointer outside of the popup window
     // this should not really change anything, it gets a leave event
     Cursor::setPos(popupClient->frameGeometry().bottomRight() + QPoint(2, 2));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 2);
     QVERIFY(popupDoneSpy.isEmpty());
     // now click, should trigger popupDone
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(popupDoneSpy.wait());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 }
 
 void PointerInputTest::testDecoCancelsPopup()
 {
     // this test verifies that clicking the window decoration of parent window
     // cancels the popup
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonStateChangedSpy.isValid());
     QSignalSpy motionSpy(pointer, &Pointer::motion);
     QVERIFY(motionSpy.isValid());
 
     Cursor::setPos(800, 800);
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
 
     auto deco = Test::waylandServerSideDecoration()->create(surface, surface);
     QSignalSpy decoSpy(deco, &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QCOMPARE(window->hasPopupGrab(), false);
     QVERIFY(window->isDecorated());
 
     // move pointer into window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursor::setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window to create serial
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(buttonStateChangedSpy.wait());
 
     // now create the popup surface
     XdgPositioner positioner(QSize(100, 50), QRect(0, 0, 80, 20));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     QSignalSpy popupDoneSpy(popupShellSurface, &XdgShellPopup::popupDone);
     QVERIFY(popupDoneSpy.isValid());
     popupShellSurface->requestGrab(Test::waylandSeat(), 0); // FIXME: Serial.
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
-    auto popupClient = clientAddedSpy.last().first().value<XdgShellClient *>();
+    auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QCOMPARE(window, workspace()->activeClient());
     QCOMPARE(popupClient->transientFor(), window);
     QCOMPARE(popupClient->pos(), window->pos() + window->clientPos() + QPoint(80, 20));
     QCOMPARE(popupClient->hasPopupGrab(), true);
 
     // let's move the pointer into the center of the deco
     Cursor::setPos(window->frameGeometry().center().x(), window->y() + (window->height() - window->clientSize().height()) / 2);
 
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     QVERIFY(popupDoneSpy.wait());
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
 }
 
 void PointerInputTest::testWindowUnderCursorWhileButtonPressed()
 {
     // this test verifies that opening a window underneath the mouse cursor does not
     // trigger a leave event if a button is pressed
     // see BUG: 372876
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     Cursor::setPos(800, 800);
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor over window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursor::setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
 
     // now create a second window as transient
     XdgPositioner positioner(QSize(99, 49), QRect(0, 0, 1, 1));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
-    auto popupClient = clientAddedSpy.last().first().value<XdgShellClient *>();
+    auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QVERIFY(window->frameGeometry().contains(Cursor::pos()));
     QVERIFY(popupClient->frameGeometry().contains(Cursor::pos()));
     QVERIFY(!leftSpy.wait());
 
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     // now that the button is no longer pressed we should get the leave event
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(enteredSpy.count(), 2);
 }
 
 void PointerInputTest::testConfineToScreenGeometry_data()
 {
     QTest::addColumn<QPoint>("startPos");
     QTest::addColumn<QPoint>("targetPos");
     QTest::addColumn<QPoint>("expectedPos");
 
     // screen layout:
     //
     // +----------+----------+---------+
     // |   left   |    top   |  right  |
     // +----------+----------+---------+
     //            |  bottom  |
     //            +----------+
     //
 
     QTest::newRow("move top-left - left screen")       << QPoint(640, 512)   << QPoint(-100, -100) << QPoint(0, 0);
     QTest::newRow("move top - left screen")            << QPoint(640, 512)   << QPoint(640, -100)  << QPoint(640, 0);
     QTest::newRow("move top-right - left screen")      << QPoint(640, 512)   << QPoint(1380, -100) << QPoint(1380, 0);
     QTest::newRow("move right - left screen")          << QPoint(640, 512)   << QPoint(1380, 512)  << QPoint(1380, 512);
     QTest::newRow("move bottom-right - left screen")   << QPoint(640, 512)   << QPoint(1380, 1124) << QPoint(1380, 1124);
     QTest::newRow("move bottom - left screen")         << QPoint(640, 512)   << QPoint(640, 1124)  << QPoint(640, 1023);
     QTest::newRow("move bottom-left - left screen")    << QPoint(640, 512)   << QPoint(-100, 1124) << QPoint(0, 1023);
     QTest::newRow("move left - left screen")           << QPoint(640, 512)   << QPoint(-100, 512)  << QPoint(0, 512);
 
     QTest::newRow("move top-left - top screen")        << QPoint(1920, 512)  << QPoint(1180, -100) << QPoint(1180, 0);
     QTest::newRow("move top - top screen")             << QPoint(1920, 512)  << QPoint(1920, -100) << QPoint(1920, 0);
     QTest::newRow("move top-right - top screen")       << QPoint(1920, 512)  << QPoint(2660, -100) << QPoint(2660, 0);
     QTest::newRow("move right - top screen")           << QPoint(1920, 512)  << QPoint(2660, 512)  << QPoint(2660, 512);
     QTest::newRow("move bottom-right - top screen")    << QPoint(1920, 512)  << QPoint(2660, 1124) << QPoint(2559, 1023);
     QTest::newRow("move bottom - top screen")          << QPoint(1920, 512)  << QPoint(1920, 1124) << QPoint(1920, 1124);
     QTest::newRow("move bottom-left - top screen")     << QPoint(1920, 512)  << QPoint(1180, 1124) << QPoint(1280, 1023);
     QTest::newRow("move left - top screen")            << QPoint(1920, 512)  << QPoint(1180, 512)  << QPoint(1180, 512);
 
     QTest::newRow("move top-left - right screen")      << QPoint(3200, 512)  << QPoint(2460, -100) << QPoint(2460, 0);
     QTest::newRow("move top - right screen")           << QPoint(3200, 512)  << QPoint(3200, -100) << QPoint(3200, 0);
     QTest::newRow("move top-right - right screen")     << QPoint(3200, 512)  << QPoint(3940, -100) << QPoint(3839, 0);
     QTest::newRow("move right - right screen")         << QPoint(3200, 512)  << QPoint(3940, 512)  << QPoint(3839, 512);
     QTest::newRow("move bottom-right - right screen")  << QPoint(3200, 512)  << QPoint(3940, 1124) << QPoint(3839, 1023);
     QTest::newRow("move bottom - right screen")        << QPoint(3200, 512)  << QPoint(3200, 1124) << QPoint(3200, 1023);
     QTest::newRow("move bottom-left - right screen")   << QPoint(3200, 512)  << QPoint(2460, 1124) << QPoint(2460, 1124);
     QTest::newRow("move left - right screen")          << QPoint(3200, 512)  << QPoint(2460, 512)  << QPoint(2460, 512);
 
     QTest::newRow("move top-left - bottom screen")     << QPoint(1920, 1536) << QPoint(1180, 924)  << QPoint(1180, 924);
     QTest::newRow("move top - bottom screen")          << QPoint(1920, 1536) << QPoint(1920, 924)  << QPoint(1920, 924);
     QTest::newRow("move top-right - bottom screen")    << QPoint(1920, 1536) << QPoint(2660, 924)  << QPoint(2660, 924);
     QTest::newRow("move right - bottom screen")        << QPoint(1920, 1536) << QPoint(2660, 1536) << QPoint(2559, 1536);
     QTest::newRow("move bottom-right - bottom screen") << QPoint(1920, 1536) << QPoint(2660, 2148) << QPoint(2559, 2047);
     QTest::newRow("move bottom - bottom screen")       << QPoint(1920, 1536) << QPoint(1920, 2148) << QPoint(1920, 2047);
     QTest::newRow("move bottom-left - bottom screen")  << QPoint(1920, 1536) << QPoint(1180, 2148) << QPoint(1280, 2047);
     QTest::newRow("move left - bottom screen")         << QPoint(1920, 1536) << QPoint(1180, 1536) << QPoint(1280, 1536);
 }
 
 void PointerInputTest::testConfineToScreenGeometry()
 {
     // this test verifies that pointer belongs to at least one screen
     // after moving it to off-screen area
 
     // unload the Present Windows effect because it pushes back
     // pointer if it's at (0, 0)
     static_cast<EffectsHandlerImpl*>(effects)->unloadEffect(QStringLiteral("presentwindows"));
 
     // setup screen layout
     const QVector<QRect> geometries {
         QRect(0, 0, 1280, 1024),
         QRect(1280, 0, 1280, 1024),
         QRect(2560, 0, 1280, 1024),
         QRect(1280, 1024, 1280, 1024)
     };
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, geometries.count()),
                               Q_ARG(QVector<QRect>, geometries));
     QCOMPARE(screens()->count(), geometries.count());
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
     QCOMPARE(screens()->geometry(2), geometries.at(2));
     QCOMPARE(screens()->geometry(3), geometries.at(3));
 
     // move pointer to initial position
     QFETCH(QPoint, startPos);
     Cursor::setPos(startPos);
     QCOMPARE(Cursor::pos(), startPos);
 
     // perform movement
     QFETCH(QPoint, targetPos);
     kwinApp()->platform()->pointerMotion(targetPos, 1);
 
     QFETCH(QPoint, expectedPos);
     QCOMPARE(Cursor::pos(), expectedPos);
 }
 
 void PointerInputTest::testResizeCursor_data()
 {
     QTest::addColumn<Qt::Edges>("edges");
     QTest::addColumn<KWin::CursorShape>("cursorShape");
 
     QTest::newRow("top-left")     << Qt::Edges(Qt::TopEdge | Qt::LeftEdge)     << CursorShape(ExtendedCursor::SizeNorthWest);
     QTest::newRow("top")          << Qt::Edges(Qt::TopEdge)                    << CursorShape(ExtendedCursor::SizeNorth);
     QTest::newRow("top-right")    << Qt::Edges(Qt::TopEdge | Qt::RightEdge)    << CursorShape(ExtendedCursor::SizeNorthEast);
     QTest::newRow("right")        << Qt::Edges(Qt::RightEdge)                  << CursorShape(ExtendedCursor::SizeEast);
     QTest::newRow("bottom-right") << Qt::Edges(Qt::BottomEdge | Qt::RightEdge) << CursorShape(ExtendedCursor::SizeSouthEast);
     QTest::newRow("bottom")       << Qt::Edges(Qt::BottomEdge)                 << CursorShape(ExtendedCursor::SizeSouth);
     QTest::newRow("bottom-left")  << Qt::Edges(Qt::BottomEdge | Qt::LeftEdge)  << CursorShape(ExtendedCursor::SizeSouthWest);
     QTest::newRow("left")         << Qt::Edges(Qt::LeftEdge)                   << CursorShape(ExtendedCursor::SizeWest);
 }
 
 void PointerInputTest::testResizeCursor()
 {
     // this test verifies that the cursor has correct shape during resize operation
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll3", "Resize");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedResize);
 
     // create a test client
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // move the cursor to the test position
     QPoint cursorPos;
     QFETCH(Qt::Edges, edges);
 
     if (edges & Qt::LeftEdge) {
         cursorPos.setX(c->frameGeometry().left());
     } else if (edges & Qt::RightEdge) {
         cursorPos.setX(c->frameGeometry().right());
     } else {
         cursorPos.setX(c->frameGeometry().center().x());
     }
 
     if (edges & Qt::TopEdge) {
         cursorPos.setY(c->frameGeometry().top());
     } else if (edges & Qt::BottomEdge) {
         cursorPos.setY(c->frameGeometry().bottom());
     } else {
         cursorPos.setY(c->frameGeometry().center().y());
     }
 
     Cursor::setPos(cursorPos);
 
     const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
     QVERIFY(!arrowCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 
     // start resizing the client
     int timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     QVERIFY(c->isResize());
 
     QFETCH(KWin::CursorShape, cursorShape);
     const PlatformCursorImage resizeCursor = loadReferenceThemeCursor(cursorShape);
     QVERIFY(!resizeCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), resizeCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), resizeCursor.hotSpot());
 
     // finish resizing the client
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     QVERIFY(!c->isResize());
 
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 }
 
 void PointerInputTest::testMoveCursor()
 {
     // this test verifies that the cursor has correct shape during move operation
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
 
     // create a test client
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
-    XdgShellClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // move cursor to the test position
     Cursor::setPos(c->frameGeometry().center());
 
     const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
     QVERIFY(!arrowCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 
     // start moving the client
     int timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(c->isMove());
 
     const PlatformCursorImage sizeAllCursor = loadReferenceThemeCursor(Qt::SizeAllCursor);
     QVERIFY(!sizeAllCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), sizeAllCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), sizeAllCursor.hotSpot());
 
     // finish moving the client
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(!c->isMove());
 
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 }
 
 void PointerInputTest::testHideShowCursor()
 {
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->hideCursor();
     kwinApp()->platform()->hideCursor();
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
 
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::PointerInputTest)
 #include "pointer_input.moc"
diff --git a/autotests/integration/quick_tiling_test.cpp b/autotests/integration/quick_tiling_test.cpp
index 7bbc0c7ee..2ad1a5d91 100644
--- a/autotests/integration/quick_tiling_test.cpp
+++ b/autotests/integration/quick_tiling_test.cpp
@@ -1,892 +1,890 @@
 /********************************************************************
 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 "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "scripting/scripting.h"
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 #include <QTemporaryFile>
 #include <QTextStream>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 #include <linux/input.h>
 
 Q_DECLARE_METATYPE(KWin::QuickTileMode)
 Q_DECLARE_METATYPE(KWin::MaximizeMode)
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_quick_tiling-0");
 
 class QuickTilingTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testQuickTiling_data();
     void testQuickTiling();
     void testQuickMaximizing_data();
     void testQuickMaximizing();
     void testQuickTilingKeyboardMove_data();
     void testQuickTilingKeyboardMove();
     void testQuickTilingPointerMove_data();
     void testQuickTilingPointerMove();
     void testQuickTilingTouchMove_data();
     void testQuickTilingTouchMove();
     void testX11QuickTiling_data();
     void testX11QuickTiling();
     void testX11QuickTilingAfterVertMaximize_data();
     void testX11QuickTilingAfterVertMaximize();
     void testShortcut_data();
     void testShortcut();
     void testScript_data();
     void testScript();
 
 private:
     KWayland::Client::ConnectionThread *m_connection = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
 };
 
 void QuickTilingTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::MaximizeMode>("MaximizeMode");
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // set custom config which disables the Outline
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup group = config->group("Outline");
     group.writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
     group.sync();
 
     kwinApp()->setConfig(config);
 
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
 }
 
 void QuickTilingTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
     m_connection = Test::waylandConnection();
     m_compositor = Test::waylandCompositor();
 
     screens()->setCurrent(0);
 }
 
 void QuickTilingTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void QuickTilingTest::testQuickTiling_data()
 {
     QTest::addColumn<QuickTileMode>("mode");
     QTest::addColumn<QRect>("expectedGeometry");
     QTest::addColumn<QRect>("secondScreen");
     QTest::addColumn<QuickTileMode>("expectedModeAfterToggle");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
 
     QTest::newRow("left")   << FLAG(Left)   << QRect(0, 0, 640, 1024)   << QRect(1280, 0, 640, 1024) << FLAG(Right);
     QTest::newRow("top")    << FLAG(Top)    << QRect(0, 0, 1280, 512)   << QRect(1280, 0, 1280, 512) << FLAG(Top);
     QTest::newRow("right")  << FLAG(Right)  << QRect(640, 0, 640, 1024) << QRect(1920, 0, 640, 1024) << QuickTileMode();
     QTest::newRow("bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512) << QRect(1280, 512, 1280, 512) << FLAG(Bottom);
 
     QTest::newRow("top left")     << (FLAG(Left)  | FLAG(Top))    << QRect(0, 0, 640, 512)     << QRect(1280, 0, 640, 512) << (FLAG(Right) | FLAG(Top));
     QTest::newRow("top right")    << (FLAG(Right) | FLAG(Top))    << QRect(640, 0, 640, 512)   << QRect(1920, 0, 640, 512) << QuickTileMode();
     QTest::newRow("bottom left")  << (FLAG(Left)  | FLAG(Bottom)) << QRect(0, 512, 640, 512)   << QRect(1280, 512, 640, 512) << (FLAG(Right)  | FLAG(Bottom));
     QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512) << QRect(1920, 512, 640, 512) << QuickTileMode();
 
     QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << QRect(1280, 0, 1280, 1024) << QuickTileMode();
 
 #undef FLAG
 }
 
 void QuickTilingTest::testQuickTiling()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Map the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
 
     // We have to receive a configure event when the client becomes active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     QFETCH(QuickTileMode, mode);
     QFETCH(QRect, expectedGeometry);
     c->setQuickTileMode(mode, true);
     QCOMPARE(quickTileChangedSpy.count(), 1);
     // at this point the geometry did not yet change
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     // but quick tile mode already changed
     QCOMPARE(c->quickTileMode(), mode);
 
     // but we got requested a new geometry
     QVERIFY(configureRequestedSpy.wait());
     QEXPECT_FAIL("maximize", "Two configure events are sent for maximized", Continue);
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), expectedGeometry.size());
 
     // attach a new image
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), expectedGeometry.size(), Qt::red);
 
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(c->frameGeometry(), expectedGeometry);
 
     // send window to other screen
     QCOMPARE(c->screen(), 0);
     c->sendToScreen(1);
     QCOMPARE(c->screen(), 1);
     // quick tile should not be changed
     QCOMPARE(c->quickTileMode(), mode);
     QTEST(c->frameGeometry(), "secondScreen");
 
     // now try to toggle again
     c->setQuickTileMode(mode, true);
     QTEST(c->quickTileMode(), "expectedModeAfterToggle");
 }
 
 void QuickTilingTest::testQuickMaximizing_data()
 {
     QTest::addColumn<QuickTileMode>("mode");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
 
     QTest::newRow("maximize") << FLAG(Maximize);
     QTest::newRow("none") << FLAG(None);
 
 #undef FLAG
 }
 
 void QuickTilingTest::testQuickMaximizing()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Map the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
     QCOMPARE(c->maximizeMode(), MaximizeRestore);
 
     // We have to receive a configure event upon becoming active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy maximizeChangedSpy1(c, qOverload<AbstractClient *, MaximizeMode>(&AbstractClient::clientMaximizedStateChanged));
     QVERIFY(maximizeChangedSpy1.isValid());
     QSignalSpy maximizeChangedSpy2(c, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged));
     QVERIFY(maximizeChangedSpy2.isValid());
 
     c->setQuickTileMode(QuickTileFlag::Maximize, true);
     QCOMPARE(quickTileChangedSpy.count(), 1);
 
     // at this point the geometry did not yet change
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     // but quick tile mode already changed
     QCOMPARE(c->quickTileMode(), QuickTileFlag::Maximize);
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
 
     // but we got requested a new geometry
     QVERIFY(configureRequestedSpy.wait());
     QEXPECT_FAIL("", "Two configure events are sent for maximized", Continue);
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
 
     // attach a new image
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::red);
 
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 1280, 1024));
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
 
     // client is now set to maximised
     QCOMPARE(maximizeChangedSpy1.count(), 1);
     QCOMPARE(maximizeChangedSpy1.first().first().value<KWin::AbstractClient*>(), c);
     QCOMPARE(maximizeChangedSpy1.first().last().value<KWin::MaximizeMode>(), MaximizeFull);
     QCOMPARE(maximizeChangedSpy2.count(), 1);
     QCOMPARE(maximizeChangedSpy2.first().first().value<KWin::AbstractClient*>(), c);
     QCOMPARE(maximizeChangedSpy2.first().at(1).toBool(), true);
     QCOMPARE(maximizeChangedSpy2.first().at(2).toBool(), true);
     QCOMPARE(c->maximizeMode(), MaximizeFull);
 
     // go back to quick tile none
     QFETCH(QuickTileMode, mode);
     c->setQuickTileMode(mode, true);
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
     QCOMPARE(quickTileChangedSpy.count(), 2);
     // geometry not yet changed
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 1280, 1024));
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
     // we got requested a new geometry
     QVERIFY(configureRequestedSpy.wait());
     QEXPECT_FAIL("", "Two configure events are sent for maximized", Continue);
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
 
     // render again
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::yellow);
 
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 2);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50));
     QCOMPARE(maximizeChangedSpy1.count(), 2);
     QCOMPARE(maximizeChangedSpy1.last().first().value<KWin::AbstractClient*>(), c);
     QCOMPARE(maximizeChangedSpy1.last().last().value<KWin::MaximizeMode>(), MaximizeRestore);
     QCOMPARE(maximizeChangedSpy2.count(), 2);
     QCOMPARE(maximizeChangedSpy2.last().first().value<KWin::AbstractClient*>(), c);
     QCOMPARE(maximizeChangedSpy2.last().at(1).toBool(), false);
     QCOMPARE(maximizeChangedSpy2.last().at(2).toBool(), false);
 }
 
 void QuickTilingTest::testQuickTilingKeyboardMove_data()
 {
     QTest::addColumn<QPoint>("targetPos");
     QTest::addColumn<QuickTileMode>("expectedMode");
 
     QTest::newRow("topRight") << QPoint(2559, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Right);
     QTest::newRow("right") << QPoint(2559, 512) << QuickTileMode(QuickTileFlag::Right);
     QTest::newRow("bottomRight") << QPoint(2559, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Right);
     QTest::newRow("bottomLeft") << QPoint(0, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Left);
     QTest::newRow("Left") << QPoint(0, 512) << QuickTileMode(QuickTileFlag::Left);
     QTest::newRow("topLeft") << QPoint(0, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Left);
 }
 
 void QuickTilingTest::testQuickTilingKeyboardMove()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     QSignalSpy sizeChangeSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeSpy.isValid());
     // let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
     QCOMPARE(c->maximizeMode(), MaximizeRestore);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
 
     workspace()->performWindowOperation(c, Options::UnrestrictedMoveOp);
     QCOMPARE(c, workspace()->moveResizeClient());
     QCOMPARE(Cursor::pos(), QPoint(49, 24));
 
     QFETCH(QPoint, targetPos);
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     while (Cursor::pos().x() > targetPos.x()) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_LEFT, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(KEY_LEFT, timestamp++);
     }
     while (Cursor::pos().x() < targetPos.x()) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     }
     while (Cursor::pos().y() < targetPos.y()) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_DOWN, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(KEY_DOWN, timestamp++);
     }
     while (Cursor::pos().y() > targetPos.y()) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_UP, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(KEY_UP, timestamp++);
     }
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_ENTER, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ENTER, timestamp++);
     QCOMPARE(Cursor::pos(), targetPos);
     QVERIFY(!workspace()->moveResizeClient());
 
     QCOMPARE(quickTileChangedSpy.count(), 1);
     QTEST(c->quickTileMode(), "expectedMode");
 }
 
 void QuickTilingTest::testQuickTilingPointerMove_data()
 {
     QTest::addColumn<QPoint>("targetPos");
     QTest::addColumn<QuickTileMode>("expectedMode");
 
     QTest::newRow("topRight") << QPoint(2559, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Right);
     QTest::newRow("right") << QPoint(2559, 512) << QuickTileMode(QuickTileFlag::Right);
     QTest::newRow("bottomRight") << QPoint(2559, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Right);
     QTest::newRow("bottomLeft") << QPoint(0, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Left);
     QTest::newRow("Left") << QPoint(0, 512) << QuickTileMode(QuickTileFlag::Left);
     QTest::newRow("topLeft") << QPoint(0, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Left);
 }
 
 void QuickTilingTest::testQuickTilingPointerMove()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellV6Surface(
         surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QVERIFY(!shellSurface.isNull());
 
     // wait for the initial configure event
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     // let's render
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
     QCOMPARE(c->maximizeMode(), MaximizeRestore);
 
     // we have to receive a configure event when the client becomes active
     QVERIFY(configureRequestedSpy.wait());
     QTRY_COMPARE(configureRequestedSpy.count(), 2);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
 
     workspace()->performWindowOperation(c, Options::UnrestrictedMoveOp);
     QCOMPARE(c, workspace()->moveResizeClient());
     QCOMPARE(Cursor::pos(), QPoint(49, 24));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
 
     QFETCH(QPoint, targetPos);
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(targetPos, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QCOMPARE(Cursor::pos(), targetPos);
     QVERIFY(!workspace()->moveResizeClient());
 
     QCOMPARE(quickTileChangedSpy.count(), 1);
     QTEST(c->quickTileMode(), "expectedMode");
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     QCOMPARE(false, configureRequestedSpy.last().first().toSize().isEmpty());
 }
 
 void QuickTilingTest::testQuickTilingTouchMove_data()
 {
     QTest::addColumn<QPoint>("targetPos");
     QTest::addColumn<QuickTileMode>("expectedMode");
 
     QTest::newRow("topRight") << QPoint(2559, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Right);
     QTest::newRow("right") << QPoint(2559, 512) << QuickTileMode(QuickTileFlag::Right);
     QTest::newRow("bottomRight") << QPoint(2559, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Right);
     QTest::newRow("bottomLeft") << QPoint(0, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Left);
     QTest::newRow("Left") << QPoint(0, 512) << QuickTileMode(QuickTileFlag::Left);
     QTest::newRow("topLeft") << QPoint(0, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Left);
 }
 
 void QuickTilingTest::testQuickTilingTouchMove()
 {
     // test verifies that touch on decoration also allows quick tiling
     // see BUG: 390113
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
 
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellV6Surface(
         surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QVERIFY(!shellSurface.isNull());
 
     // wait for the initial configure event
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     // let's render
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(1000, 50), Qt::blue);
 
     QVERIFY(c);
     QVERIFY(c->isDecorated());
     const auto decoration = c->decoration();
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(-decoration->borderLeft(), 0,
                                        1000 + decoration->borderLeft() + decoration->borderRight(),
                                        50 + decoration->borderTop() + decoration->borderBottom()));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
     QCOMPARE(c->maximizeMode(), MaximizeRestore);
 
     // we have to receive a configure event when the client becomes active
     QVERIFY(configureRequestedSpy.wait());
     QTRY_COMPARE(configureRequestedSpy.count(), 2);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(0, QPointF(c->frameGeometry().center().x(), c->frameGeometry().y() + decoration->borderTop() / 2), timestamp++);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(c, workspace()->moveResizeClient());
     QCOMPARE(configureRequestedSpy.count(), 3);
 
     QFETCH(QPoint, targetPos);
     kwinApp()->platform()->touchMotion(0, targetPos, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(!workspace()->moveResizeClient());
 
 
     // When there are no borders, there is no change to them when quick-tiling.
     // TODO: we should test both cases with fixed fake decoration for autotests.
     const bool hasBorders = Decoration::DecorationBridge::self()->settings()->borderSize() != KDecoration2::BorderSize::None;
 
     QCOMPARE(quickTileChangedSpy.count(), 1);
     QTEST(c->quickTileMode(), "expectedMode");
     QVERIFY(configureRequestedSpy.wait());
     QTRY_COMPARE(configureRequestedSpy.count(), hasBorders ? 5 : 4);
     QCOMPARE(false, configureRequestedSpy.last().first().toSize().isEmpty());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void QuickTilingTest::testX11QuickTiling_data()
 {
     QTest::addColumn<QuickTileMode>("mode");
     QTest::addColumn<QRect>("expectedGeometry");
     QTest::addColumn<int>("screen");
     QTest::addColumn<QuickTileMode>("modeAfterToggle");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
 
     QTest::newRow("left")   << FLAG(Left)   << QRect(0, 0, 640, 1024) << 0 << QuickTileMode();
     QTest::newRow("top")    << FLAG(Top)    << QRect(0, 0, 1280, 512) << 1 << FLAG(Top);
     QTest::newRow("right")  << FLAG(Right)  << QRect(640, 0, 640, 1024) << 1 << FLAG(Left);
     QTest::newRow("bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512) << 1 << FLAG(Bottom);
 
     QTest::newRow("top left")     << (FLAG(Left)  | FLAG(Top))    << QRect(0, 0, 640, 512) << 0 << QuickTileMode();
     QTest::newRow("top right")    << (FLAG(Right) | FLAG(Top))    << QRect(640, 0, 640, 512) << 1 << (FLAG(Left) | FLAG(Top));
     QTest::newRow("bottom left")  << (FLAG(Left)  | FLAG(Bottom)) << QRect(0, 512, 640, 512) << 0 << QuickTileMode();
     QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512) << 1 << (FLAG(Left) | FLAG(Bottom));
 
     QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << 0 << QuickTileMode();
 
 #undef FLAG
 }
 void QuickTilingTest::testX11QuickTiling()
 {
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
 
     // now quick tile
     QSignalSpy quickTileChangedSpy(client, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     const QRect origGeo = client->frameGeometry();
     QFETCH(QuickTileMode, mode);
     client->setQuickTileMode(mode, true);
     QCOMPARE(client->quickTileMode(), mode);
     QTEST(client->frameGeometry(), "expectedGeometry");
     QCOMPARE(client->geometryRestore(), origGeo);
     QEXPECT_FAIL("maximize", "For maximize we get two changed signals", Continue);
     QCOMPARE(quickTileChangedSpy.count(), 1);
 
     // quick tile to same edge again should also act like send to screen
     QCOMPARE(client->screen(), 0);
     client->setQuickTileMode(mode, true);
     QTEST(client->screen(), "screen");
     QTEST(client->quickTileMode(), "modeAfterToggle");
     QCOMPARE(client->geometryRestore(), origGeo);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void QuickTilingTest::testX11QuickTilingAfterVertMaximize_data()
 {
     QTest::addColumn<QuickTileMode>("mode");
     QTest::addColumn<QRect>("expectedGeometry");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
 
     QTest::newRow("left")   << FLAG(Left)   << QRect(0, 0, 640, 1024);
     QTest::newRow("top")    << FLAG(Top)    << QRect(0, 0, 1280, 512);
     QTest::newRow("right")  << FLAG(Right)  << QRect(640, 0, 640, 1024);
     QTest::newRow("bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512);
 
     QTest::newRow("top left")     << (FLAG(Left)  | FLAG(Top))    << QRect(0, 0, 640, 512);
     QTest::newRow("top right")    << (FLAG(Right) | FLAG(Top))    << QRect(640, 0, 640, 512);
     QTest::newRow("bottom left")  << (FLAG(Left)  | FLAG(Bottom)) << QRect(0, 512, 640, 512);
     QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512);
 
     QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024);
 
 #undef FLAG
 }
 
 void QuickTilingTest::testX11QuickTilingAfterVertMaximize()
 {
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
 
     const QRect origGeo = client->frameGeometry();
     QCOMPARE(client->maximizeMode(), MaximizeRestore);
     // vertically maximize the window
     client->maximize(client->maximizeMode() ^ MaximizeVertical);
     QCOMPARE(client->frameGeometry().width(), origGeo.width());
     QCOMPARE(client->height(), screens()->size(client->screen()).height());
     QCOMPARE(client->geometryRestore(), origGeo);
 
     // now quick tile
     QSignalSpy quickTileChangedSpy(client, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     QFETCH(QuickTileMode, mode);
     client->setQuickTileMode(mode, true);
     QCOMPARE(client->quickTileMode(), mode);
     QTEST(client->frameGeometry(), "expectedGeometry");
     QEXPECT_FAIL("", "We get two changed events", Continue);
     QCOMPARE(quickTileChangedSpy.count(), 1);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void QuickTilingTest::testShortcut_data()
 {
     QTest::addColumn<QString>("shortcut");
     QTest::addColumn<QuickTileMode>("expectedMode");
     QTest::addColumn<QRect>("expectedGeometry");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
     QTest::newRow("top") << QStringLiteral("Window Quick Tile Top") << FLAG(Top) << QRect(0, 0, 1280, 512);
     QTest::newRow("left") << QStringLiteral("Window Quick Tile Left") << FLAG(Left) << QRect(0, 0, 640, 1024);
     QTest::newRow("bottom") << QStringLiteral("Window Quick Tile Bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512);
     QTest::newRow("right") << QStringLiteral("Window Quick Tile Right") << FLAG(Right) << QRect(640, 0, 640, 1024);
 
     QTest::newRow("top right") << QStringLiteral("Window Quick Tile Top Right") << (FLAG(Top) | FLAG(Right)) << QRect(640, 0, 640, 512);
     QTest::newRow("top left") << QStringLiteral("Window Quick Tile Top Left") << (FLAG(Top) | FLAG(Left)) << QRect(0, 0, 640, 512);
     QTest::newRow("bottom right") << QStringLiteral("Window Quick Tile Bottom Right") << (FLAG(Bottom) | FLAG(Right)) << QRect(640, 512, 640, 512);
     QTest::newRow("bottom left") << QStringLiteral("Window Quick Tile Bottom Left") << (FLAG(Bottom) | FLAG(Left)) << QRect(0, 512, 640, 512);
 
 #undef FLAG
 }
 
 void QuickTilingTest::testShortcut()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Map the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
 
     // We have to receive a configure event when the client becomes active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QFETCH(QString, shortcut);
     QFETCH(QRect, expectedGeometry);
 
     // invoke global shortcut through dbus
     auto msg = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.kglobalaccel"),
         QStringLiteral("/component/kwin"),
         QStringLiteral("org.kde.kglobalaccel.Component"),
         QStringLiteral("invokeShortcut"));
     msg.setArguments(QList<QVariant>{shortcut});
     QDBusConnection::sessionBus().asyncCall(msg);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     QVERIFY(quickTileChangedSpy.wait());
     QCOMPARE(quickTileChangedSpy.count(), 1);
     // at this point the geometry did not yet change
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     // but quick tile mode already changed
     QTEST(c->quickTileMode(), "expectedMode");
 
     // but we got requested a new geometry
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), expectedGeometry.size());
 
     // attach a new image
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), expectedGeometry.size(), Qt::red);
 
     QVERIFY(frameGeometryChangedSpy.wait());
     QEXPECT_FAIL("maximize", "Geometry changed called twice for maximize", Continue);
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(c->frameGeometry(), expectedGeometry);
 }
 
 void QuickTilingTest::testScript_data()
 {
     QTest::addColumn<QString>("action");
     QTest::addColumn<QuickTileMode>("expectedMode");
     QTest::addColumn<QRect>("expectedGeometry");
 
 #define FLAG(name) QuickTileMode(QuickTileFlag::name)
     QTest::newRow("top") << QStringLiteral("Top") << FLAG(Top) << QRect(0, 0, 1280, 512);
     QTest::newRow("left") << QStringLiteral("Left") << FLAG(Left) << QRect(0, 0, 640, 1024);
     QTest::newRow("bottom") << QStringLiteral("Bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512);
     QTest::newRow("right") << QStringLiteral("Right") << FLAG(Right) << QRect(640, 0, 640, 1024);
 
     QTest::newRow("top right") << QStringLiteral("TopRight") << (FLAG(Top) | FLAG(Right)) << QRect(640, 0, 640, 512);
     QTest::newRow("top left") << QStringLiteral("TopLeft") << (FLAG(Top) | FLAG(Left)) << QRect(0, 0, 640, 512);
     QTest::newRow("bottom right") << QStringLiteral("BottomRight") << (FLAG(Bottom) | FLAG(Right)) << QRect(640, 512, 640, 512);
     QTest::newRow("bottom left") << QStringLiteral("BottomLeft") << (FLAG(Bottom) | FLAG(Left)) << QRect(0, 512, 640, 512);
 
 #undef FLAG
 }
 
 void QuickTilingTest::testScript()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Map the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(workspace()->activeClient(), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None));
 
     // We have to receive a configure event upon the client becoming active.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged);
     QVERIFY(quickTileChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     QVERIFY(Scripting::self());
     QTemporaryFile tmpFile;
     QVERIFY(tmpFile.open());
     QTextStream out(&tmpFile);
 
     QFETCH(QString, action);
     out << "workspace.slotWindowQuickTile" << action << "()";
     out.flush();
 
     QFETCH(QuickTileMode, expectedMode);
     QFETCH(QRect, expectedGeometry);
 
     const int id = Scripting::self()->loadScript(tmpFile.fileName());
     QVERIFY(id != -1);
     QVERIFY(Scripting::self()->isScriptLoaded(tmpFile.fileName()));
     auto s = Scripting::self()->findScript(tmpFile.fileName());
     QVERIFY(s);
     QSignalSpy runningChangedSpy(s, &AbstractScript::runningChanged);
     QVERIFY(runningChangedSpy.isValid());
     s->run();
 
     QVERIFY(quickTileChangedSpy.wait());
     QCOMPARE(quickTileChangedSpy.count(), 1);
 
     QCOMPARE(runningChangedSpy.count(), 1);
     QCOMPARE(runningChangedSpy.first().first().toBool(), true);
 
     // at this point the geometry did not yet change
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 50));
     // but quick tile mode already changed
     QCOMPARE(c->quickTileMode(), expectedMode);
 
     // but we got requested a new geometry
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), expectedGeometry.size());
 
     // attach a new image
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), expectedGeometry.size(), Qt::red);
 
     QVERIFY(frameGeometryChangedSpy.wait());
     QEXPECT_FAIL("maximize", "Geometry changed called twice for maximize", Continue);
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(c->frameGeometry(), expectedGeometry);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::QuickTilingTest)
 #include "quick_tiling_test.moc"
diff --git a/autotests/integration/scene_opengl_shadow_test.cpp b/autotests/integration/scene_opengl_shadow_test.cpp
index 476bb257c..0e4c920a7 100644
--- a/autotests/integration/scene_opengl_shadow_test.cpp
+++ b/autotests/integration/scene_opengl_shadow_test.cpp
@@ -1,864 +1,863 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 <algorithm>
 
 #include <QByteArray>
 #include <QDir>
 #include <QObject>
 #include <QPair>
 #include <QVector>
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationShadow>
 
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/shadow_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include "kwin_wayland_test.h"
 
+#include "abstract_client.h"
 #include "composite.h"
 #include "effect_builtins.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "shadow.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 Q_DECLARE_METATYPE(KWin::WindowQuadList);
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_opengl_shadow-0");
 
 class SceneOpenGLShadowTest : public QObject
 {
     Q_OBJECT
 
 public:
     SceneOpenGLShadowTest() {}
 
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
 
     void testShadowTileOverlaps_data();
     void testShadowTileOverlaps();
     void testNoCornerShadowTiles();
     void testDistributeHugeCornerTiles();
 
 };
 
 inline bool isClose(double a, double b, double eps = 1e-5)
 {
     if (a == b) {
         return true;
     }
     const double diff = std::fabs(a - b);
     if (a == 0 || b == 0) {
         return diff < eps;
     }
     return diff / std::max(a, b) < eps;
 }
 
 inline bool compareQuads(const WindowQuad &a, const WindowQuad &b)
 {
     for (int i = 0; i < 4; i++) {
         if (!isClose(a[i].x(), b[i].x())
                 || !isClose(a[i].y(), b[i].y())
                 || !isClose(a[i].u(), b[i].u())
                 || !isClose(a[i].v(), b[i].v())) {
             return false;
         }
     }
     return true;
 }
 
 inline WindowQuad makeShadowQuad(const QRectF &geo, qreal tx1, qreal ty1, qreal tx2, qreal ty2)
 {
     WindowQuad quad(WindowQuadShadow);
     quad[0] = WindowVertex(geo.left(),  geo.top(),    tx1, ty1);
     quad[1] = WindowVertex(geo.right(), geo.top(),    tx2, ty1);
     quad[2] = WindowVertex(geo.right(), geo.bottom(), tx2, ty2);
     quad[3] = WindowVertex(geo.left(),  geo.bottom(), tx1, ty2);
     return quad;
 }
 
 void SceneOpenGLShadowTest::initTestCase()
 {
     // Copied from generic_scene_opengl_test.cpp
 
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 
     // Add directory with fake decorations to the plugin search path.
     QCoreApplication::addLibraryPath(
         QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("fakes")
     );
 
     // Change decoration theme.
     KConfigGroup group = kwinApp()->config()->group("org.kde.kdecoration2");
     group.writeEntry("library", "org.kde.test.fakedecowithshadows");
     group.sync();
     Workspace::self()->slotReconfigure();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 
 }
 
 void SceneOpenGLShadowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 namespace {
     const int SHADOW_SIZE = 128;
 
     const int SHADOW_OFFSET_TOP  = 64;
     const int SHADOW_OFFSET_LEFT = 48;
 
     // NOTE: We assume deco shadows are generated with blur so that's
     //       why there is 4, 1 is the size of the inner shadow rect.
     const int SHADOW_TEXTURE_WIDTH  = 4 * SHADOW_SIZE + 1;
     const int SHADOW_TEXTURE_HEIGHT = 4 * SHADOW_SIZE + 1;
 
     const int SHADOW_PADDING_TOP    = SHADOW_SIZE - SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_RIGHT  = SHADOW_SIZE + SHADOW_OFFSET_LEFT;
     const int SHADOW_PADDING_BOTTOM = SHADOW_SIZE + SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_LEFT   = SHADOW_SIZE - SHADOW_OFFSET_LEFT;
 
     const QRectF SHADOW_INNER_RECT(2 * SHADOW_SIZE, 2 * SHADOW_SIZE, 1, 1);
 }
 
 void SceneOpenGLShadowTest::testShadowTileOverlaps_data()
 {
     QTest::addColumn<QSize>("windowSize");
     QTest::addColumn<WindowQuadList>("expectedQuads");
 
     // Precompute shadow tile geometries(in texture's space).
     const QRectF topLeftTile(
         0,
         0,
         SHADOW_INNER_RECT.x(),
         SHADOW_INNER_RECT.y());
     const QRectF topRightTile(
         SHADOW_INNER_RECT.right(),
         0,
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.y());
     const QRectF topTile(topLeftTile.topRight(), topRightTile.bottomLeft());
 
     const QRectF bottomLeftTile(
         0,
         SHADOW_INNER_RECT.bottom(),
         SHADOW_INNER_RECT.x(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomRightTile(
         SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.bottom(),
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomTile(bottomLeftTile.topRight(), bottomRightTile.bottomLeft());
 
     const QRectF leftTile(topLeftTile.bottomLeft(), bottomLeftTile.topRight());
     const QRectF rightTile(topRightTile.bottomLeft(), bottomRightTile.topRight());
 
     qreal tx1 = 0;
     qreal ty1 = 0;
     qreal tx2 = 0;
     qreal ty2 = 0;
 
     // Explanation behind numbers: (256+1 x 256+1) is the minimum window size
     // which doesn't cause overlapping of shadow tiles. For example, if a window
     // has (256 x 256+1) size, top-left and top-right or bottom-left and
     // bottom-right shadow tiles overlap.
 
     // No overlaps: In this case corner tiles are rendered as they are,
     // and top/right/bottom/left tiles are stretched.
     {
         const QSize windowSize(256 + 1, 256 + 1);
         WindowQuadList shadowQuads;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         const QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         const QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
         tx1 = topRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topRightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
         tx1 = bottomLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         const QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
         tx1 = bottomRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = leftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = leftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = leftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = rightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = rightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = rightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = rightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow("no overlaps") << windowSize << shadowQuads;
     }
 
     // Top-Left & Bottom-Left/Top-Right & Bottom-Right overlap:
     // In this case overlapping parts are clipped and left/right
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> verticalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap"),
             QSize(256 + 1, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap :: pre"),
             QSize(256 + 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : verticalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - halfOverlap);
         bottomLeft.setTop(bottomLeft.top() + halfOverlap);
 
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeft.height()     / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomLeft.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomLeftTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - halfOverlap);
         bottomRight.setTop(bottomRight.top() + halfOverlap);
 
         tx1 = topRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topRight.height()     / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomRightTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomRight.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomRightTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left()  / SHADOW_TEXTURE_WIDTH;
         ty1 = topTile.top()   / SHADOW_TEXTURE_HEIGHT;
         tx2 = topTile.right() / SHADOW_TEXTURE_WIDTH;
         ty2 = top.height()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottom.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Top-Left & Top-Right/Bottom-Left & Bottom-Right overlap:
     // In this case overlapping parts are clipped and top/bottom
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> horizontalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap"),
             QSize(256, 256 + 1)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap :: pre"),
             QSize(256 - 1, 256 + 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : horizontalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - halfOverlap);
         topRight.setLeft(topRight.left() + halfOverlap);
 
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeft.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (topRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = topRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topRightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - halfOverlap);
         bottomRight.setLeft(bottomRight.left() + halfOverlap);
 
         tx1 = bottomLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomLeft.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (bottomRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = bottomRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = leftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = left.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = leftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = 1.0 - (right.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = rightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = rightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = rightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // All shadow tiles overlap: In this case all overlapping parts
     // are clippend and top/right/bottom/left tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> allOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap"),
             QSize(256, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap :: pre"),
             QSize(256 - 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : allOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - halfOverlap);
         topRight.setLeft(topRight.left() + halfOverlap);
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - halfOverlap);
         bottomRight.setLeft(bottomRight.left() + halfOverlap);
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - halfOverlap);
         bottomLeft.setTop(bottomLeft.top() + halfOverlap);
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - halfOverlap);
         bottomRight.setTop(bottomRight.top() + halfOverlap);
 
         tx1 = topLeftTile.left() / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()  / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeft.width()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeft.height()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (topRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = topRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topRight.height()       / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomLeft.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomLeft.width()         / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (bottomRight.width()  / SHADOW_TEXTURE_WIDTH);
         ty1 = 1.0 - (bottomRight.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomRightTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Window is too small: do not render any shadow tiles.
     {
         const QSize windowSize(1, 1);
         const WindowQuadList shadowQuads;
 
         QTest::newRow("window is too small") << windowSize << shadowQuads;
     }
 }
 
 void SceneOpenGLShadowTest::testShadowTileOverlaps()
 {
     QFETCH(QSize, windowSize);
     QFETCH(WindowQuadList, expectedQuads);
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     // Create a decorated client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto *client = Test::renderAndWaitForShown(surface.data(), windowSize, Qt::blue);
 
     QSignalSpy sizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangedSpy.isValid());
 
     // Check the client is decorated.
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     auto *decoration = client->decoration();
     QVERIFY(decoration);
 
     // If speciefied decoration theme is not found, KWin loads a default one
     // so we have to check whether a client has right decoration.
     auto decoShadow = decoration->shadow();
     QCOMPARE(decoShadow->shadow().size(), QSize(SHADOW_TEXTURE_WIDTH, SHADOW_TEXTURE_HEIGHT));
     QCOMPARE(decoShadow->paddingTop(),    SHADOW_PADDING_TOP);
     QCOMPARE(decoShadow->paddingRight(),  SHADOW_PADDING_RIGHT);
     QCOMPARE(decoShadow->paddingBottom(), SHADOW_PADDING_BOTTOM);
     QCOMPARE(decoShadow->paddingLeft(),   SHADOW_PADDING_LEFT);
 
     // Get shadow.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto *shadow = client->effectWindow()->sceneWindow()->shadow();
 
     // Validate shadow quads.
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.size(), expectedQuads.size());
 
     QVector<bool> mask(expectedQuads.size(), false);
     for (const auto &q : quads) {
         for (int i = 0; i < expectedQuads.size(); i++) {
             if (!compareQuads(q, expectedQuads[i])) {
                 continue;
             }
             if (!mask[i]) {
                 mask[i] = true;
                 break;
             } else {
                 QFAIL("got a duplicate shadow quad");
             }
         }
     }
 
     for (const auto &v : qAsConst(mask)) {
         if (!v) {
             QFAIL("missed a shadow quad");
         }
     }
 }
 
 void SceneOpenGLShadowTest::testNoCornerShadowTiles()
 {
     // this test verifies that top/right/bottom/left shadow tiles are
     // still drawn even when corner tiles are missing
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(512, 512), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Render reference shadow texture with the following params:
     //  - shadow size: 128
     //  - inner rect size: 1
     //  - padding: 128
     QImage referenceShadowTexture(256 + 1, 256 + 1, QImage::Format_ARGB32_Premultiplied);
     referenceShadowTexture.fill(Qt::transparent);
 
     // We don't care about content of the shadow.
 
     // Submit the shadow to KWin.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTop = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 0, 1, 128)));
     clientShadow->attachTop(bufferTop);
 
     Buffer::Ptr bufferRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128, 128, 1)));
     clientShadow->attachRight(bufferRight);
 
     Buffer::Ptr bufferBottom = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 128 + 1, 1, 128)));
     clientShadow->attachBottom(bufferBottom);
 
     Buffer::Ptr bufferLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128, 128, 1)));
     clientShadow->attachLeft(bufferLeft);
 
     clientShadow->setOffsets(QMarginsF(128, 128, 128, 128));
 
     QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check that we got right shadow from the client.
     QPointer<KWayland::Server::ShadowInterface> shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   128.0);
     QCOMPARE(shadowIface->offset().top(),    128.0);
     QCOMPARE(shadowIface->offset().right(),  128.0);
     QCOMPARE(shadowIface->offset().bottom(), 128.0);
 
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     KWin::Shadow *shadow = client->effectWindow()->sceneWindow()->shadow();
     QVERIFY(shadow != nullptr);
 
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.count(), 4);
 
     // Shadow size: 128
     // Padding: QMargins(128, 128, 128, 128)
     // Inner rect: QRect(128, 128, 1, 1)
     // Texture size: QSize(257, 257)
     // Window size: QSize(512, 512)
     WindowQuadList expectedQuads;
     expectedQuads << makeShadowQuad(QRectF(   0, -128, 512, 128), 128.0 / 257.0,           0.0, 129.0 / 257.0, 128.0 / 257.0); // top
     expectedQuads << makeShadowQuad(QRectF( 512,    0, 128, 512), 129.0 / 257.0, 128.0 / 257.0,           1.0, 129.0 / 257.0); // right
     expectedQuads << makeShadowQuad(QRectF(   0,  512, 512, 128), 128.0 / 257.0, 129.0 / 257.0, 129.0 / 257.0, 1.0);           // bottom
     expectedQuads << makeShadowQuad(QRectF(-128,    0, 128, 512),           0.0, 128.0 / 257.0, 128.0 / 257.0, 129.0 / 257.0); // left
 
     for (const WindowQuad &expectedQuad : expectedQuads) {
         auto it = std::find_if(quads.constBegin(), quads.constEnd(),
             [&expectedQuad](const WindowQuad &quad) {
                 return compareQuads(quad, expectedQuad);
             });
         if (it == quads.constEnd()) {
             const QString message = QStringLiteral("Missing shadow quad (left: %1, top: %2, right: %3, bottom: %4)")
                 .arg(expectedQuad.left())
                 .arg(expectedQuad.top())
                 .arg(expectedQuad.right())
                 .arg(expectedQuad.bottom());
             const QByteArray rawMessage = message.toLocal8Bit().data();
             QFAIL(rawMessage.data());
         }
     }
 }
 
 void SceneOpenGLShadowTest::testDistributeHugeCornerTiles()
 {
     // this test verifies that huge corner tiles are distributed correctly
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(64, 64), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Submit the shadow to KWin.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     QImage referenceTileTexture(512, 512, QImage::Format_ARGB32_Premultiplied);
     referenceTileTexture.fill(Qt::transparent);
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTopLeft = shmPool->createBuffer(referenceTileTexture);
     clientShadow->attachTopLeft(bufferTopLeft);
 
     Buffer::Ptr bufferTopRight = shmPool->createBuffer(referenceTileTexture);
     clientShadow->attachTopRight(bufferTopRight);
 
     clientShadow->setOffsets(QMarginsF(256, 256, 256, 0));
 
     QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check that we got right shadow from the client.
     QPointer<KWayland::Server::ShadowInterface> shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   256.0);
     QCOMPARE(shadowIface->offset().top(),    256.0);
     QCOMPARE(shadowIface->offset().right(),  256.0);
     QCOMPARE(shadowIface->offset().bottom(), 0.0);
 
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     KWin::Shadow *shadow = client->effectWindow()->sceneWindow()->shadow();
     QVERIFY(shadow != nullptr);
 
     WindowQuadList expectedQuads;
 
     // Top-left quad
     expectedQuads << makeShadowQuad(
         QRectF(-256, -256, 256 + 32, 256 + 64),
         0.0, 0.0, (256.0 + 32.0) / 1024.0, (256.0 + 64.0) / 512.0);
 
     // Top-right quad
     expectedQuads << makeShadowQuad(
         QRectF(32, -256, 256 + 32, 256 + 64),
         1.0 - (256.0 + 32.0) / 1024.0, 0.0, 1.0, (256.0 + 64.0) / 512.0);
 
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.count(), expectedQuads.count());
 
     for (const WindowQuad &expectedQuad : expectedQuads) {
         auto it = std::find_if(quads.constBegin(), quads.constEnd(),
             [&expectedQuad](const WindowQuad &quad) {
                 return compareQuads(quad, expectedQuad);
             });
         if (it == quads.constEnd()) {
             const QString message = QStringLiteral("Missing shadow quad (left: %1, top: %2, right: %3, bottom: %4)")
                 .arg(expectedQuad.left())
                 .arg(expectedQuad.top())
                 .arg(expectedQuad.right())
                 .arg(expectedQuad.bottom());
             const QByteArray rawMessage = message.toLocal8Bit().data();
             QFAIL(rawMessage.data());
         }
     }
 }
 
 WAYLANDTEST_MAIN(SceneOpenGLShadowTest)
 #include "scene_opengl_shadow_test.moc"
diff --git a/autotests/integration/scene_qpainter_shadow_test.cpp b/autotests/integration/scene_qpainter_shadow_test.cpp
index ecd176a1e..b45d7a13d 100644
--- a/autotests/integration/scene_qpainter_shadow_test.cpp
+++ b/autotests/integration/scene_qpainter_shadow_test.cpp
@@ -1,781 +1,780 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 <algorithm>
 #include <cmath>
 
 #include <QByteArray>
 #include <QDir>
 #include <QImage>
 #include <QMarginsF>
 #include <QObject>
 #include <QPainter>
 #include <QPair>
 #include <QVector>
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationShadow>
 
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Server/shadow_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include "kwin_wayland_test.h"
 
+#include "abstract_client.h"
 #include "composite.h"
 #include "effect_builtins.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "plugins/scenes/qpainter/scene_qpainter.h"
 #include "shadow.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 Q_DECLARE_METATYPE(KWin::WindowQuadList)
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_qpainter_shadow-0");
 
 class SceneQPainterShadowTest : public QObject
 {
     Q_OBJECT
 
 public:
     SceneQPainterShadowTest() {}
 
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
 
     void testShadowTileOverlaps_data();
     void testShadowTileOverlaps();
     void testShadowTextureReconstruction();
 
 };
 
 inline bool isClose(double a, double b, double eps = 1e-5)
 {
     if (a == b) {
         return true;
     }
     const double diff = std::fabs(a - b);
     if (a == 0 || b == 0) {
         return diff < eps;
     }
     return diff / std::max(a, b) < eps;
 }
 
 inline bool compareQuads(const WindowQuad &a, const WindowQuad &b)
 {
     for (int i = 0; i < 4; i++) {
         if (!isClose(a[i].x(), b[i].x())
                 || !isClose(a[i].y(), b[i].y())
                 || !isClose(a[i].textureX(), b[i].textureX())
                 || !isClose(a[i].textureY(), b[i].textureY())) {
             return false;
         }
     }
     return true;
 }
 
 inline WindowQuad makeShadowQuad(const QRectF &geo, qreal tx1, qreal ty1, qreal tx2, qreal ty2)
 {
     WindowQuad quad(WindowQuadShadow);
     quad[0] = WindowVertex(geo.left(),  geo.top(),    tx1, ty1);
     quad[1] = WindowVertex(geo.right(), geo.top(),    tx2, ty1);
     quad[2] = WindowVertex(geo.right(), geo.bottom(), tx2, ty2);
     quad[3] = WindowVertex(geo.left(),  geo.bottom(), tx1, ty2);
     return quad;
 }
 
 void SceneQPainterShadowTest::initTestCase()
 {
     // Copied from scene_qpainter_test.cpp
 
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("Q"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 
     // Add directory with fake decorations to the plugin search path.
     QCoreApplication::addLibraryPath(
         QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("fakes")
     );
 
     // Change decoration theme.
     KConfigGroup group = kwinApp()->config()->group("org.kde.kdecoration2");
     group.writeEntry("library", "org.kde.test.fakedecowithshadows");
     group.sync();
     Workspace::self()->slotReconfigure();
 }
 
 void SceneQPainterShadowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 namespace {
     const int SHADOW_SIZE = 128;
 
     const int SHADOW_OFFSET_TOP  = 64;
     const int SHADOW_OFFSET_LEFT = 48;
 
     // NOTE: We assume deco shadows are generated with blur so that's
     //       why there is 4, 1 is the size of the inner shadow rect.
     const int SHADOW_TEXTURE_WIDTH  = 4 * SHADOW_SIZE + 1;
     const int SHADOW_TEXTURE_HEIGHT = 4 * SHADOW_SIZE + 1;
 
     const int SHADOW_PADDING_TOP    = SHADOW_SIZE - SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_RIGHT  = SHADOW_SIZE + SHADOW_OFFSET_LEFT;
     const int SHADOW_PADDING_BOTTOM = SHADOW_SIZE + SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_LEFT   = SHADOW_SIZE - SHADOW_OFFSET_LEFT;
 
     const QRectF SHADOW_INNER_RECT(2 * SHADOW_SIZE, 2 * SHADOW_SIZE, 1, 1);
 }
 
 void SceneQPainterShadowTest::testShadowTileOverlaps_data()
 {
     QTest::addColumn<QSize>("windowSize");
     QTest::addColumn<WindowQuadList>("expectedQuads");
 
     // Precompute shadow tile geometries(in texture's space).
     const QRectF topLeftTile(
         0,
         0,
         SHADOW_INNER_RECT.x(),
         SHADOW_INNER_RECT.y());
     const QRectF topRightTile(
         SHADOW_INNER_RECT.right(),
         0,
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.y());
     const QRectF topTile(topLeftTile.topRight(), topRightTile.bottomLeft());
 
     const QRectF bottomLeftTile(
         0,
         SHADOW_INNER_RECT.bottom(),
         SHADOW_INNER_RECT.x(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomRightTile(
         SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.bottom(),
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomTile(bottomLeftTile.topRight(), bottomRightTile.bottomLeft());
 
     const QRectF leftTile(topLeftTile.bottomLeft(), bottomLeftTile.topRight());
     const QRectF rightTile(topRightTile.bottomLeft(), bottomRightTile.topRight());
 
     qreal tx1 = 0;
     qreal ty1 = 0;
     qreal tx2 = 0;
     qreal ty2 = 0;
 
     // Explanation behind numbers: (256+1 x 256+1) is the minimum window size
     // which doesn't cause overlapping of shadow tiles. For example, if a window
     // has (256 x 256+1) size, top-left and top-right or bottom-left and
     // bottom-right shadow tiles overlap.
 
     // No overlaps: In this case corner tiles are rendered as they are,
     // and top/right/bottom/left tiles are stretched.
     {
         const QSize windowSize(256 + 1, 256 + 1);
         WindowQuadList shadowQuads;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         const QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeftTile.right();
         ty2 = topLeftTile.bottom();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         const QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
         tx1 = topRightTile.left();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRightTile.bottom();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left();
         ty1 = topTile.top();
         tx2 = topTile.right();
         ty2 = topTile.bottom();
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
         tx1 = bottomLeftTile.left();
         ty1 = bottomLeftTile.top();
         tx2 = bottomLeftTile.right();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         const QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
         tx1 = bottomRightTile.left();
         ty1 = bottomRightTile.top();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left();
         ty1 = bottomTile.top();
         tx2 = bottomTile.right();
         ty2 = bottomTile.bottom();
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left();
         ty1 = leftTile.top();
         tx2 = leftTile.right();
         ty2 = leftTile.bottom();
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = rightTile.left();
         ty1 = rightTile.top();
         tx2 = rightTile.right();
         ty2 = rightTile.bottom();
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow("no overlaps") << windowSize << shadowQuads;
     }
 
     // Top-Left & Bottom-Left/Top-Right & Bottom-Right overlap:
     // In this case overlapping parts are clipped and left/right
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> verticalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap"),
             QSize(256 + 1, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap :: pre"),
             QSize(256 + 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : verticalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - std::floor(halfOverlap));
         bottomLeft.setTop(bottomLeft.top() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeftTile.right();
         ty2 = topLeft.height();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomLeft.height();
         tx2 = bottomLeftTile.right();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - std::floor(halfOverlap));
         bottomRight.setTop(bottomRight.top() + std::ceil(halfOverlap));
 
         tx1 = topRightTile.left();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRight.height();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomRightTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomRight.height();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left();
         ty1 = topTile.top();
         tx2 = topTile.right();
         ty2 = top.height();
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottom.height();
         tx2 = bottomTile.right();
         ty2 = bottomTile.bottom();
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Top-Left & Top-Right/Bottom-Left & Bottom-Right overlap:
     // In this case overlapping parts are clipped and top/bottom
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> horizontalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap"),
             QSize(256, 256 + 1)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap :: pre"),
             QSize(256 - 1, 256 + 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : horizontalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - std::floor(halfOverlap));
         topRight.setLeft(topRight.left() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeft.width();
         ty2 = topLeftTile.bottom();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - topRight.width();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRightTile.bottom();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - std::floor(halfOverlap));
         bottomRight.setLeft(bottomRight.left() + std::ceil(halfOverlap));
 
         tx1 = bottomLeftTile.left();
         ty1 = bottomLeftTile.top();
         tx2 = bottomLeft.width();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - bottomRight.width();
         ty1 = bottomRightTile.top();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left();
         ty1 = leftTile.top();
         tx2 = left.width();
         ty2 = leftTile.bottom();
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = SHADOW_TEXTURE_WIDTH - right.width();
         ty1 = rightTile.top();
         tx2 = rightTile.right();
         ty2 = rightTile.bottom();
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // All shadow tiles overlap: In this case all overlapping parts
     // are clippend and top/right/bottom/left tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> allOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap"),
             QSize(256, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap :: pre"),
             QSize(256 - 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : allOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - std::floor(halfOverlap));
         topRight.setLeft(topRight.left() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - std::floor(halfOverlap));
         bottomRight.setLeft(bottomRight.left() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - std::floor(halfOverlap));
         bottomLeft.setTop(bottomLeft.top() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - std::floor(halfOverlap));
         bottomRight.setTop(bottomRight.top() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeft.width();
         ty2 = topLeft.height();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - topRight.width();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRight.height();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomLeft.height();
         tx2 = bottomLeft.width();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - bottomRight.width();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomRight.height();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Window is too small: do not render any shadow tiles.
     {
         const QSize windowSize(1, 1);
         const WindowQuadList shadowQuads;
 
         QTest::newRow("window is too small") << windowSize << shadowQuads;
     }
 }
 
 void SceneQPainterShadowTest::testShadowTileOverlaps()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     QFETCH(QSize, windowSize);
     QFETCH(WindowQuadList, expectedQuads);
 
     // Create a decorated client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto *client = Test::renderAndWaitForShown(surface.data(), windowSize, Qt::blue);
 
     QSignalSpy sizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangedSpy.isValid());
 
     // Check the client is decorated.
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     auto *decoration = client->decoration();
     QVERIFY(decoration);
 
     // If speciefied decoration theme is not found, KWin loads a default one
     // so we have to check whether a client has right decoration.
     auto decoShadow = decoration->shadow();
     QCOMPARE(decoShadow->shadow().size(), QSize(SHADOW_TEXTURE_WIDTH, SHADOW_TEXTURE_HEIGHT));
     QCOMPARE(decoShadow->paddingTop(),    SHADOW_PADDING_TOP);
     QCOMPARE(decoShadow->paddingRight(),  SHADOW_PADDING_RIGHT);
     QCOMPARE(decoShadow->paddingBottom(), SHADOW_PADDING_BOTTOM);
     QCOMPARE(decoShadow->paddingLeft(),   SHADOW_PADDING_LEFT);
 
     // Get shadow.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto *shadow = client->effectWindow()->sceneWindow()->shadow();
 
     // Validate shadow quads.
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.size(), expectedQuads.size());
 
     QVector<bool> mask(expectedQuads.size(), false);
     for (const auto &q : quads) {
         for (int i = 0; i < expectedQuads.size(); i++) {
             if (!compareQuads(q, expectedQuads[i])) {
                 continue;
             }
             if (!mask[i]) {
                 mask[i] = true;
                 break;
             } else {
                 QFAIL("got a duplicate shadow quad");
             }
         }
     }
 
     for (const auto &v : qAsConst(mask)) {
         if (!v) {
             QFAIL("missed a shadow quad");
         }
     }
 }
 
 void SceneQPainterShadowTest::testShadowTextureReconstruction()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(512, 512), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Render reference shadow texture with the following params:
     //  - shadow size: 128
     //  - inner rect size: 1
     //  - padding: 128
     QImage referenceShadowTexture(QSize(256 + 1, 256 + 1), QImage::Format_ARGB32_Premultiplied);
     referenceShadowTexture.fill(Qt::transparent);
 
     QPainter painter(&referenceShadowTexture);
     painter.fillRect(QRect(10, 10, 192, 200), QColor(255, 0, 0, 128));
     painter.fillRect(QRect(128, 30, 10, 180), QColor(0, 0, 0, 30));
     painter.fillRect(QRect(20, 140, 160, 10), QColor(0, 255, 0, 128));
 
     painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
     painter.fillRect(QRect(128, 128, 1, 1), Qt::black);
     painter.end();
 
     // Create shadow.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTopLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 0, 128, 128)));
     clientShadow->attachTopLeft(bufferTopLeft);
 
     Buffer::Ptr bufferTop = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 0, 1, 128)));
     clientShadow->attachTop(bufferTop);
 
     Buffer::Ptr bufferTopRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 0, 128, 128)));
     clientShadow->attachTopRight(bufferTopRight);
 
     Buffer::Ptr bufferRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128, 128, 1)));
     clientShadow->attachRight(bufferRight);
 
     Buffer::Ptr bufferBottomRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128 + 1, 128, 128)));
     clientShadow->attachBottomRight(bufferBottomRight);
 
     Buffer::Ptr bufferBottom = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 128 + 1, 1, 128)));
     clientShadow->attachBottom(bufferBottom);
 
     Buffer::Ptr bufferBottomLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128 + 1, 128, 128)));
     clientShadow->attachBottomLeft(bufferBottomLeft);
 
     Buffer::Ptr bufferLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128, 128, 1)));
     clientShadow->attachLeft(bufferLeft);
 
     clientShadow->setOffsets(QMarginsF(128, 128, 128, 128));
 
     // Commit shadow.
     QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check whether we've got right shadow.
     auto shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   128.0);
     QCOMPARE(shadowIface->offset().top(),    128.0);
     QCOMPARE(shadowIface->offset().right(),  128.0);
     QCOMPARE(shadowIface->offset().bottom(), 128.0);
 
     // Get SceneQPainterShadow's texture.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto &shadowTexture = static_cast<SceneQPainterShadow *>(client->effectWindow()->sceneWindow()->shadow())->shadowTexture();
 
     QCOMPARE(shadowTexture, referenceShadowTexture);
 }
 
 WAYLANDTEST_MAIN(SceneQPainterShadowTest)
 #include "scene_qpainter_shadow_test.moc"
diff --git a/autotests/integration/scene_qpainter_test.cpp b/autotests/integration/scene_qpainter_test.cpp
index bea96577b..f3f362ee5 100644
--- a/autotests/integration/scene_qpainter_test.cpp
+++ b/autotests/integration/scene_qpainter_test.cpp
@@ -1,393 +1,391 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "effects.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "effect_builtins.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include <QPainter>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_qpainter-0");
 
 class SceneQPainterTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void testStartFrame();
     void testCursorMoving();
     void testWindow_data();
     void testWindow();
     void testWindowScaled();
     void testCompositorRestart_data();
     void testCompositorRestart();
     void testX11Window();
 };
 
 void SceneQPainterTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void SceneQPainterTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("Q"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 }
 
 void SceneQPainterTest::testStartFrame()
 {
     // this test verifies that the initial rendering is correct
     Compositor::self()->addRepaintFull();
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(kwinApp()->platform()->selectedCompositor(), QPainterCompositing);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
     // now let's render a reference image for comparison
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter p(&referenceImage);
     const QImage cursorImage = kwinApp()->platform()->softwareCursor();
     QVERIFY(!cursorImage.isNull());
     p.drawImage(KWin::Cursor::pos() - kwinApp()->platform()->softwareCursorHotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testCursorMoving()
 {
     // this test verifies that rendering is correct also after moving the cursor a few times
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     KWin::Cursor::setPos(0, 0);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursor::setPos(10, 0);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursor::setPos(10, 12);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursor::setPos(12, 14);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursor::setPos(50, 60);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursor::setPos(45, 45);
     QVERIFY(frameRenderedSpy.wait());
     // now let's render a reference image for comparison
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter p(&referenceImage);
     const QImage cursorImage = kwinApp()->platform()->softwareCursor();
     QVERIFY(!cursorImage.isNull());
     p.drawImage(QPoint(45, 45) - kwinApp()->platform()->softwareCursorHotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void SceneQPainterTest::testWindow()
 {
     KWin::Cursor::setPos(45, 45);
     // this test verifies that a window is rendered correctly
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     QScopedPointer<Surface> s(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellSurface(type, s.data()));
     QScopedPointer<Pointer> p(Test::waylandSeat()->createPointer());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
 
     // now let's map the window
     QVERIFY(Test::renderAndWaitForShown(s.data(), QSize(200, 300), Qt::blue));
     // which should trigger a frame
     if (frameRenderedSpy.isEmpty()) {
         QVERIFY(frameRenderedSpy.wait());
     }
     // we didn't set a cursor image on the surface yet, so it should be just black + window and previous cursor
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
 
     // now let's set a cursor image
     QScopedPointer<Surface> cs(Test::createSurface());
     QVERIFY(!cs.isNull());
     Test::render(cs.data(), QSize(10, 10), Qt::red);
     p->setCursor(cs.data(), QPoint(5, 5));
     QVERIFY(frameRenderedSpy.wait());
     painter.fillRect(KWin::Cursor::pos().x() - 5, KWin::Cursor::pos().y() - 5, 10, 10, Qt::red);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
     // let's move the cursor again
     KWin::Cursor::setPos(10, 10);
     QVERIFY(frameRenderedSpy.wait());
     painter.fillRect(0, 0, 200, 300, Qt::blue);
     painter.fillRect(5, 5, 10, 10, Qt::red);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testWindowScaled()
 {
     KWin::Cursor::setPos(10, 10);
     // this test verifies that a window is rendered correctly
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     QScopedPointer<Surface> s(Test::createSurface());
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellStableSurface(s.data()));
     QScopedPointer<Pointer> p(Test::waylandSeat()->createPointer());
     QSignalSpy pointerEnteredSpy(p.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
 
     // now let's set a cursor image
     QScopedPointer<Surface> cs(Test::createSurface());
     QVERIFY(!cs.isNull());
     Test::render(cs.data(), QSize(10, 10), Qt::red);
 
     // now let's map the window
     s->setScale(2);
 
     //draw a blue square@400x600 with red rectangle@200x200 in the middle
     const QSize size(400,600);
     QImage img(size, QImage::Format_ARGB32_Premultiplied);
     img.fill(Qt::blue);
     QPainter surfacePainter(&img);
     surfacePainter.fillRect(200,300,200,200, Qt::red);
 
     //add buffer
     Test::render(s.data(), img);
     QVERIFY(pointerEnteredSpy.wait());
     p->setCursor(cs.data(), QPoint(5, 5));
 
     // which should trigger a frame
     QVERIFY(frameRenderedSpy.wait());
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
     painter.fillRect(100, 150, 100, 100, Qt::red);
     painter.fillRect(5, 5, 10, 10, Qt::red); //cursor
 
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testCompositorRestart_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void SceneQPainterTest::testCompositorRestart()
 {
     // this test verifies that the compositor/SceneQPainter survive a restart of the compositor and still render correctly
     KWin::Cursor::setPos(400, 400);
 
     // first create a window
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection());
     QScopedPointer<Surface> s(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellSurface(type, s.data()));
     QVERIFY(Test::renderAndWaitForShown(s.data(), QSize(200, 300), Qt::blue));
 
     // now let's try to reinitialize the compositing scene
     auto oldScene = KWin::Compositor::self()->scene();
     QVERIFY(oldScene);
     QSignalSpy sceneCreatedSpy(KWin::Compositor::self(), &KWin::Compositor::sceneCreated);
     QVERIFY(sceneCreatedSpy.isValid());
     KWin::Compositor::self()->reinitialize();
     if (sceneCreatedSpy.isEmpty()) {
         QVERIFY(sceneCreatedSpy.wait());
     }
     QCOMPARE(sceneCreatedSpy.count(), 1);
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
 
     // this should directly trigger a frame
     KWin::Compositor::self()->addRepaintFull();
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
 
     // render reference image
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
     const QImage cursorImage = kwinApp()->platform()->softwareCursor();
     QVERIFY(!cursorImage.isNull());
     painter.drawImage(QPoint(400, 400) - kwinApp()->platform()->softwareCursorHotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void SceneQPainterTest::testX11Window()
 {
     // this test verifies the condition of BUG: 382748
 
     // create X11 window
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     uint32_t value = defaultScreen()->white_pixel;
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL, &value);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QCOMPARE(client->clientSize(), QSize(100, 200));
     if (!client->surface()) {
         // wait for surface
         QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
         QVERIFY(surfaceChangedSpy.isValid());
         QVERIFY(surfaceChangedSpy.wait());
     }
     QVERIFY(client->surface());
     QTRY_VERIFY(client->surface()->buffer());
     QTRY_COMPARE(client->surface()->buffer()->data().size(), client->size());
     QImage compareImage(client->clientSize(), QImage::Format_RGB32);
     compareImage.fill(Qt::white);
     QCOMPARE(client->surface()->buffer()->data().copy(QRect(client->clientPos(), client->clientSize())), compareImage);
 
     // enough time for rendering the window
     QTest::qWait(100);
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
 
     // this should directly trigger a frame
     KWin::Compositor::self()->addRepaintFull();
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
 
     const QPoint startPos = client->pos() + client->clientPos();
     auto image = scene->qpainterRenderBuffer();
     QCOMPARE(image->copy(QRect(startPos, client->clientSize())), compareImage);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 WAYLANDTEST_MAIN(SceneQPainterTest)
 #include "scene_qpainter_test.moc"
diff --git a/autotests/integration/screenedge_client_show_test.cpp b/autotests/integration/screenedge_client_show_test.cpp
index 5dd68a26a..1aecfec8e 100644
--- a/autotests/integration/screenedge_client_show_test.cpp
+++ b/autotests/integration/screenedge_client_show_test.cpp
@@ -1,296 +1,294 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_screenedge_client_show-0");
 
 class ScreenEdgeClientShowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testScreenEdgeShowHideX11_data();
     void testScreenEdgeShowHideX11();
     void testScreenEdgeShowX11Touch_data();
     void testScreenEdgeShowX11Touch();
 };
 
 void ScreenEdgeClientShowTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // set custom config which disable touch edge
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup group = config->group("TabBox");
     group.writeEntry(QStringLiteral("TouchBorderActivate"), "9");
     group.sync();
 
     kwinApp()->setConfig(config);
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void ScreenEdgeClientShowTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
     QVERIFY(waylandServer()->clients().isEmpty());
 }
 
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void ScreenEdgeClientShowTest::testScreenEdgeShowHideX11_data()
 {
     QTest::addColumn<QRect>("windowGeometry");
     QTest::addColumn<QRect>("resizedWindowGeometry");
     QTest::addColumn<quint32>("location");
     QTest::addColumn<QPoint>("triggerPos");
 
     QTest::newRow("bottom/left") << QRect(50, 1004, 1180, 20) << QRect(150, 1004, 1000, 20) << 2u << QPoint(100, 1023);
     QTest::newRow("bottom/right") << QRect(1330, 1004, 1180, 20) << QRect(1410, 1004, 1000, 20) << 2u << QPoint(1400, 1023);
     QTest::newRow("top/left") << QRect(50, 0, 1180, 20) << QRect(150, 0, 1000, 20) << 0u << QPoint(100, 0);
     QTest::newRow("top/right") << QRect(1330, 0, 1180, 20) << QRect(1410, 0, 1000, 20) << 0u << QPoint(1400, 0);
     QTest::newRow("left") << QRect(0, 10, 20, 1000) << QRect(0, 70, 20, 800) << 3u << QPoint(0, 50);
     QTest::newRow("right") << QRect(2540, 10, 20, 1000) << QRect(2540, 70, 20, 800) << 1u << QPoint(2559, 60);
 }
 
 void ScreenEdgeClientShowTest::testScreenEdgeShowHideX11()
 {
     // this test creates a window which borders the screen and sets the screenedge show hint
     // that should trigger a show of the window whenever the cursor is pushed against the screen edge
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     // atom for the screenedge show hide functionality
     Xcb::Atom atom(QByteArrayLiteral("_KDE_NET_WM_SCREEN_EDGE_SHOW"), false, c.data());
 
     xcb_window_t w = xcb_generate_id(c.data());
     QFETCH(QRect, windowGeometry);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->frameGeometry(), windowGeometry);
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
 
     QSignalSpy effectsWindowAdded(effects, &EffectsHandler::windowAdded);
     QVERIFY(effectsWindowAdded.isValid());
     QVERIFY(effectsWindowAdded.wait());
 
     // now try to hide
     QFETCH(quint32, location);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atom, XCB_ATOM_CARDINAL, 32, 1, &location);
     xcb_flush(c.data());
 
     QSignalSpy effectsWindowHiddenSpy(effects, &EffectsHandler::windowHidden);
     QVERIFY(effectsWindowHiddenSpy.isValid());
     QSignalSpy clientHiddenSpy(client, &X11Client::windowHidden);
     QVERIFY(clientHiddenSpy.isValid());
     QVERIFY(clientHiddenSpy.wait());
     QVERIFY(client->isHiddenInternal());
     QCOMPARE(effectsWindowHiddenSpy.count(), 1);
 
     // now trigger the edge
     QSignalSpy effectsWindowShownSpy(effects, &EffectsHandler::windowShown);
     QVERIFY(effectsWindowShownSpy.isValid());
     QFETCH(QPoint, triggerPos);
     Cursor::setPos(triggerPos);
     QVERIFY(!client->isHiddenInternal());
     QCOMPARE(effectsWindowShownSpy.count(), 1);
 
     // go into event loop to trigger xcb_flush
     QTest::qWait(1);
 
     //hide window again
     Cursor::setPos(QPoint(640, 512));
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atom, XCB_ATOM_CARDINAL, 32, 1, &location);
     xcb_flush(c.data());
     QVERIFY(clientHiddenSpy.wait());
     QVERIFY(client->isHiddenInternal());
     QFETCH(QRect, resizedWindowGeometry);
     //resizewhile hidden
     client->setFrameGeometry(resizedWindowGeometry);
     //triggerPos shouldn't be valid anymore
     Cursor::setPos(triggerPos);
     QVERIFY(client->isHiddenInternal());
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void ScreenEdgeClientShowTest::testScreenEdgeShowX11Touch_data()
 {
     QTest::addColumn<QRect>("windowGeometry");
     QTest::addColumn<quint32>("location");
     QTest::addColumn<QPoint>("touchDownPos");
     QTest::addColumn<QPoint>("targetPos");
 
     QTest::newRow("bottom/left") << QRect(50, 1004, 1180, 20) << 2u << QPoint(100, 1023) << QPoint(100, 540);
     QTest::newRow("bottom/right") << QRect(1330, 1004, 1180, 20) << 2u << QPoint(1400, 1023) << QPoint(1400, 520);
     QTest::newRow("top/left") << QRect(50, 0, 1180, 20) << 0u << QPoint(100, 0) << QPoint(100, 350);
     QTest::newRow("top/right") << QRect(1330, 0, 1180, 20) << 0u << QPoint(1400, 0) << QPoint(1400, 400);
     QTest::newRow("left") << QRect(0, 10, 20, 1000) << 3u << QPoint(0, 50) << QPoint(400, 50);
     QTest::newRow("right") << QRect(2540, 10, 20, 1000) << 1u << QPoint(2559, 60) << QPoint(2200, 60);
 }
 
 void ScreenEdgeClientShowTest::testScreenEdgeShowX11Touch()
 {
     // this test creates a window which borders the screen and sets the screenedge show hint
     // that should trigger a show of the window whenever the touch screen swipe gesture is triggered
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     // atom for the screenedge show hide functionality
     Xcb::Atom atom(QByteArrayLiteral("_KDE_NET_WM_SCREEN_EDGE_SHOW"), false, c.data());
 
     xcb_window_t w = xcb_generate_id(c.data());
     QFETCH(QRect, windowGeometry);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->frameGeometry(), windowGeometry);
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
 
     QSignalSpy effectsWindowAdded(effects, &EffectsHandler::windowAdded);
     QVERIFY(effectsWindowAdded.isValid());
     QVERIFY(effectsWindowAdded.wait());
 
     // now try to hide
     QFETCH(quint32, location);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atom, XCB_ATOM_CARDINAL, 32, 1, &location);
     xcb_flush(c.data());
 
     QSignalSpy effectsWindowHiddenSpy(effects, &EffectsHandler::windowHidden);
     QVERIFY(effectsWindowHiddenSpy.isValid());
     QSignalSpy clientHiddenSpy(client, &X11Client::windowHidden);
     QVERIFY(clientHiddenSpy.isValid());
     QVERIFY(clientHiddenSpy.wait());
     QVERIFY(client->isHiddenInternal());
     QCOMPARE(effectsWindowHiddenSpy.count(), 1);
 
     // now trigger the edge
     QSignalSpy effectsWindowShownSpy(effects, &EffectsHandler::windowShown);
     QVERIFY(effectsWindowShownSpy.isValid());
     quint32 timestamp = 0;
     QFETCH(QPoint, touchDownPos);
     QFETCH(QPoint, targetPos);
     kwinApp()->platform()->touchDown(0, touchDownPos, timestamp++);
     kwinApp()->platform()->touchMotion(0, targetPos, timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(effectsWindowShownSpy.wait());
     QVERIFY(!client->isHiddenInternal());
     QCOMPARE(effectsWindowShownSpy.count(), 1);
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::ScreenEdgeClientShowTest)
 #include "screenedge_client_show_test.moc"
diff --git a/autotests/integration/scripting/minimizeall_test.cpp b/autotests/integration/scripting/minimizeall_test.cpp
index 914f4cb94..3412b4412 100644
--- a/autotests/integration/scripting/minimizeall_test.cpp
+++ b/autotests/integration/scripting/minimizeall_test.cpp
@@ -1,170 +1,169 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
+#include "abstract_client.h"
 #include "platform.h"
 #include "screens.h"
 #include "scripting/scripting.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 
 #include <KPackage/PackageLoader>
 #include <KWayland/Client/surface.h>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_minimizeall-0");
 static const QString s_scriptName = QStringLiteral("minimizeall");
 
 class MinimizeAllScriptTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMinimizeUnminimize();
 };
 
 void MinimizeAllScriptTest::initTestCase()
 {
     qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
 
     qRegisterMetaType<AbstractClient *>();
-    qRegisterMetaType<XdgShellClient *>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 static QString locateMainScript(const QString &pluginName)
 {
     const QList<KPluginMetaData> offers = KPackage::PackageLoader::self()->findPackages(
         QStringLiteral("KWin/Script"),
         QStringLiteral("kwin/scripts"),
         [&](const KPluginMetaData &metaData) {
             return metaData.pluginId() == pluginName;
         }
     );
     if (offers.isEmpty()) {
         return QString();
     }
     const KPluginMetaData &metaData = offers.first();
     const QString mainScriptFileName = metaData.value(QStringLiteral("X-Plasma-MainScript"));
     const QFileInfo metaDataFileInfo(metaData.fileName());
     return metaDataFileInfo.path() + QLatin1String("/contents/") + mainScriptFileName;
 }
 
 void MinimizeAllScriptTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 
     Scripting::self()->loadScript(locateMainScript(s_scriptName), s_scriptName);
     QTRY_VERIFY(Scripting::self()->isScriptLoaded(s_scriptName));
 
     AbstractScript *script = Scripting::self()->findScript(s_scriptName);
     QVERIFY(script);
     QSignalSpy runningChangedSpy(script, &AbstractScript::runningChanged);
     QVERIFY(runningChangedSpy.isValid());
     script->run();
     QTRY_COMPARE(runningChangedSpy.count(), 1);
 }
 
 void MinimizeAllScriptTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     Scripting::self()->unloadScript(s_scriptName);
     QTRY_VERIFY(!Scripting::self()->isScriptLoaded(s_scriptName));
 }
 
 void MinimizeAllScriptTest::testMinimizeUnminimize()
 {
     // This test verifies that all windows are minimized when Meta+Shift+D
     // is pressed, and unminimized when the shortcut is pressed once again.
 
     using namespace KWayland::Client;
 
     // Create a couple of test clients.
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
-    XdgShellClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1);
     QVERIFY(client1->isActive());
     QVERIFY(client1->isMinimizable());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
-    XdgShellClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::red);
+    AbstractClient *client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::red);
     QVERIFY(client2);
     QVERIFY(client2->isActive());
     QVERIFY(client2->isMinimizable());
 
     // Minimize the windows.
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_D, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_D, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     QTRY_VERIFY(client1->isMinimized());
     QTRY_VERIFY(client2->isMinimized());
 
     // Unminimize the windows.
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_D, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_D, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     QTRY_VERIFY(!client1->isMinimized());
     QTRY_VERIFY(!client2->isMinimized());
 
     // Destroy test clients.
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(client2));
     shellSurface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(client1));
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::MinimizeAllScriptTest)
 #include "minimizeall_test.moc"
diff --git a/autotests/integration/shade_test.cpp b/autotests/integration/shade_test.cpp
index 7691556d9..556eae234 100644
--- a/autotests/integration/shade_test.cpp
+++ b/autotests/integration/shade_test.cpp
@@ -1,143 +1,141 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KDecoration2/Decoration>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_shade-0");
 
 class ShadeTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testShadeGeometry();
 };
 
 void ShadeTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void ShadeTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void ShadeTest::testShadeGeometry()
 {
     // this test verifies that the geometry is properly restored after shading
     // see BUG: 362501
     // create an xcb window
     struct XcbConnectionDeleter
     {
         static inline void cleanup(xcb_connection_t *pointer)
         {
             xcb_disconnect(pointer);
         }
     };
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QVERIFY(client->isShadeable());
     QVERIFY(!client->isShade());
     QVERIFY(client->isActive());
 
     // now shade the window
     const QRect geoBeforeShade = client->frameGeometry();
     QVERIFY(geoBeforeShade.isValid());
     QVERIFY(!geoBeforeShade.isEmpty());
     workspace()->slotWindowShade();
     QVERIFY(client->isShade());
     QVERIFY(client->frameGeometry() != geoBeforeShade);
     // and unshade again
     workspace()->slotWindowShade();
     QVERIFY(!client->isShade());
     QCOMPARE(client->frameGeometry(), geoBeforeShade);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::ShadeTest)
 #include "shade_test.moc"
diff --git a/autotests/integration/showing_desktop_test.cpp b/autotests/integration/showing_desktop_test.cpp
index 20f505f44..1ceb47cb0 100644
--- a/autotests/integration/showing_desktop_test.cpp
+++ b/autotests/integration/showing_desktop_test.cpp
@@ -1,127 +1,126 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_showing_desktop-0");
 
 class ShowingDesktopTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testRestoreFocus();
     void testRestoreFocusWithDesktopWindow();
 };
 
 void ShowingDesktopTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void ShowingDesktopTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::PlasmaShell));
 }
 
 void ShowingDesktopTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void ShowingDesktopTest::testRestoreFocus()
 {
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1 != client2);
 
     QCOMPARE(workspace()->activeClient(), client2);
     workspace()->slotToggleShowDesktop();
     QVERIFY(workspace()->showingDesktop());
     workspace()->slotToggleShowDesktop();
     QVERIFY(!workspace()->showingDesktop());
 
     QVERIFY(workspace()->activeClient());
     QCOMPARE(workspace()->activeClient(), client2);
 }
 
 void ShowingDesktopTest::testRestoreFocusWithDesktopWindow()
 {
     // first create a desktop window
 
     QScopedPointer<Surface> desktopSurface(Test::createSurface());
     QVERIFY(!desktopSurface.isNull());
     QScopedPointer<XdgShellSurface> desktopShellSurface(Test::createXdgShellStableSurface(desktopSurface.data()));
     QVERIFY(!desktopSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(desktopSurface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Desktop);
 
     auto desktop = Test::renderAndWaitForShown(desktopSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(desktop);
     QVERIFY(desktop->isDesktop());
 
     // now create some windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto client2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client1 != client2);
 
     QCOMPARE(workspace()->activeClient(), client2);
     workspace()->slotToggleShowDesktop();
     QVERIFY(workspace()->showingDesktop());
     QCOMPARE(workspace()->activeClient(), desktop);
     workspace()->slotToggleShowDesktop();
     QVERIFY(!workspace()->showingDesktop());
 
     QVERIFY(workspace()->activeClient());
     QCOMPARE(workspace()->activeClient(), client2);
 }
 
 WAYLANDTEST_MAIN(ShowingDesktopTest)
 #include "showing_desktop_test.moc"
diff --git a/autotests/integration/stacking_order_test.cpp b/autotests/integration/stacking_order_test.cpp
index a8eb3b2f3..20d5a72d4 100644
--- a/autotests/integration/stacking_order_test.cpp
+++ b/autotests/integration/stacking_order_test.cpp
@@ -1,910 +1,908 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "atoms.h"
 #include "x11client.h"
 #include "deleted.h"
 #include "main.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/surface.h>
 
 #include <xcb/xcb.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_stacking_order-0");
 
 class StackingOrderTest : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testTransientIsAboveParent();
     void testRaiseTransient();
     void testDeletedTransient();
 
     void testGroupTransientIsAboveWindowGroup();
     void testRaiseGroupTransient();
     void testDeletedGroupTransient();
     void testDontKeepAboveNonModalDialogGroupTransients();
 
     void testKeepAbove();
     void testKeepBelow();
 
 };
 
 void StackingOrderTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::Deleted *>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void StackingOrderTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void StackingOrderTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void StackingOrderTest::testTransientIsAboveParent()
 {
     // This test verifies that transients are always above their parents.
 
     // Create the parent.
     KWayland::Client::Surface *parentSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(parentSurface);
     KWayland::Client::XdgShellSurface *parentShellSurface =
         Test::createXdgShellStableSurface(parentSurface, parentSurface);
     QVERIFY(parentShellSurface);
-    XdgShellClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
+    AbstractClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
     QVERIFY(parent);
     QVERIFY(parent->isActive());
     QVERIFY(!parent->isTransient());
 
     // Initially, the stacking order should contain only the parent window.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent}));
 
     // Create the transient.
     KWayland::Client::Surface *transientSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
     KWayland::Client::XdgShellSurface *transientShellSurface =
         Test::createXdgShellStableSurface(transientSurface, transientSurface);
     QVERIFY(transientShellSurface);
     transientShellSurface->setTransientFor(parentShellSurface);
-    XdgShellClient *transient = Test::renderAndWaitForShown(
+    AbstractClient *transient = Test::renderAndWaitForShown(
         transientSurface, QSize(128, 128), Qt::red);
     QVERIFY(transient);
     QVERIFY(transient->isActive());
     QVERIFY(transient->isTransient());
 
     // The transient should be above the parent.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient}));
 
     // The transient still stays above the parent if we activate the latter.
     workspace()->activateClient(parent);
     QTRY_VERIFY(parent->isActive());
     QTRY_VERIFY(!transient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient}));
 }
 
 void StackingOrderTest::testRaiseTransient()
 {
     // This test verifies that both the parent and the transient will be
     // raised if either one of them is activated.
 
     // Create the parent.
     KWayland::Client::Surface *parentSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(parentSurface);
     KWayland::Client::XdgShellSurface *parentShellSurface =
         Test::createXdgShellStableSurface(parentSurface, parentSurface);
     QVERIFY(parentShellSurface);
-    XdgShellClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
+    AbstractClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
     QVERIFY(parent);
     QVERIFY(parent->isActive());
     QVERIFY(!parent->isTransient());
 
     // Initially, the stacking order should contain only the parent window.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent}));
 
     // Create the transient.
     KWayland::Client::Surface *transientSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
     KWayland::Client::XdgShellSurface *transientShellSurface =
         Test::createXdgShellStableSurface(transientSurface, transientSurface);
     QVERIFY(transientShellSurface);
     transientShellSurface->setTransientFor(parentShellSurface);
-    XdgShellClient *transient = Test::renderAndWaitForShown(
+    AbstractClient *transient = Test::renderAndWaitForShown(
         transientSurface, QSize(128, 128), Qt::red);
     QVERIFY(transient);
     QTRY_VERIFY(transient->isActive());
     QVERIFY(transient->isTransient());
 
     // The transient should be above the parent.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient}));
 
     // Create a window that doesn't have any relationship to the parent or the transient.
     KWayland::Client::Surface *anotherSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(anotherSurface);
     KWayland::Client::XdgShellSurface *anotherShellSurface =
         Test::createXdgShellStableSurface(anotherSurface, anotherSurface);
     QVERIFY(anotherShellSurface);
-    XdgShellClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
+    AbstractClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
     QVERIFY(anotherClient);
     QVERIFY(anotherClient->isActive());
     QVERIFY(!anotherClient->isTransient());
 
     // The newly created surface has to be above both the parent and the transient.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient, anotherClient}));
 
     // If we activate the parent, the transient should be raised too.
     workspace()->activateClient(parent);
     QTRY_VERIFY(parent->isActive());
     QTRY_VERIFY(!transient->isActive());
     QTRY_VERIFY(!anotherClient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{anotherClient, parent, transient}));
 
     // Go back to the initial setup.
     workspace()->activateClient(anotherClient);
     QTRY_VERIFY(!parent->isActive());
     QTRY_VERIFY(!transient->isActive());
     QTRY_VERIFY(anotherClient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient, anotherClient}));
 
     // If we activate the transient, the parent should be raised too.
     workspace()->activateClient(transient);
     QTRY_VERIFY(!parent->isActive());
     QTRY_VERIFY(transient->isActive());
     QTRY_VERIFY(!anotherClient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{anotherClient, parent, transient}));
 }
 
 struct WindowUnrefDeleter
 {
     static inline void cleanup(Deleted *d) {
         if (d != nullptr) {
             d->unrefWindow();
         }
     }
 };
 
 void StackingOrderTest::testDeletedTransient()
 {
     // This test verifies that deleted transients are kept above their
     // old parents.
 
     // Create the parent.
     KWayland::Client::Surface *parentSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(parentSurface);
     KWayland::Client::XdgShellSurface *parentShellSurface =
         Test::createXdgShellStableSurface(parentSurface, parentSurface);
     QVERIFY(parentShellSurface);
-    XdgShellClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
+    AbstractClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
     QVERIFY(parent);
     QVERIFY(parent->isActive());
     QVERIFY(!parent->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent}));
 
     // Create the first transient.
     KWayland::Client::Surface *transient1Surface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(transient1Surface);
     KWayland::Client::XdgShellSurface *transient1ShellSurface =
         Test::createXdgShellStableSurface(transient1Surface, transient1Surface);
     QVERIFY(transient1ShellSurface);
     transient1ShellSurface->setTransientFor(parentShellSurface);
-    XdgShellClient *transient1 = Test::renderAndWaitForShown(
+    AbstractClient *transient1 = Test::renderAndWaitForShown(
         transient1Surface, QSize(128, 128), Qt::red);
     QVERIFY(transient1);
     QTRY_VERIFY(transient1->isActive());
     QVERIFY(transient1->isTransient());
     QCOMPARE(transient1->transientFor(), parent);
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient1}));
 
     // Create the second transient.
     KWayland::Client::Surface *transient2Surface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(transient2Surface);
     KWayland::Client::XdgShellSurface *transient2ShellSurface =
         Test::createXdgShellStableSurface(transient2Surface, transient2Surface);
     QVERIFY(transient2ShellSurface);
     transient2ShellSurface->setTransientFor(transient1ShellSurface);
-    XdgShellClient *transient2 = Test::renderAndWaitForShown(
+    AbstractClient *transient2 = Test::renderAndWaitForShown(
         transient2Surface, QSize(128, 128), Qt::red);
     QVERIFY(transient2);
     QTRY_VERIFY(transient2->isActive());
     QVERIFY(transient2->isTransient());
     QCOMPARE(transient2->transientFor(), transient1);
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient1, transient2}));
 
     // Activate the parent, both transients have to be above it.
     workspace()->activateClient(parent);
     QTRY_VERIFY(parent->isActive());
     QTRY_VERIFY(!transient1->isActive());
     QTRY_VERIFY(!transient2->isActive());
 
     // Close the top-most transient.
-    connect(transient2, &XdgShellClient::windowClosed, this,
+    connect(transient2, &AbstractClient::windowClosed, this,
         [](Toplevel *toplevel, Deleted *deleted) {
             Q_UNUSED(toplevel)
             deleted->refWindow();
         }
     );
 
-    QSignalSpy windowClosedSpy(transient2, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(transient2, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     delete transient2ShellSurface;
     delete transient2Surface;
     QVERIFY(windowClosedSpy.wait());
 
     QScopedPointer<Deleted, WindowUnrefDeleter> deletedTransient(
         windowClosedSpy.first().at(1).value<Deleted *>());
     QVERIFY(deletedTransient.data());
 
     // The deleted transient still has to be above its old parent (transient1).
     QTRY_VERIFY(parent->isActive());
     QTRY_VERIFY(!transient1->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{parent, transient1, deletedTransient.data()}));
 }
 
 static xcb_window_t createGroupWindow(xcb_connection_t *conn,
                                       const QRect &geometry,
                                       xcb_window_t leaderWid = XCB_WINDOW_NONE)
 {
     xcb_window_t wid = xcb_generate_id(conn);
     xcb_create_window(
         conn,                          // c
         XCB_COPY_FROM_PARENT,          // depth
         wid,                           // wid
         rootWindow(),                  // parent
         geometry.x(),                  // x
         geometry.y(),                  // y
         geometry.width(),              // width
         geometry.height(),             // height
         0,                             // border_width
         XCB_WINDOW_CLASS_INPUT_OUTPUT, // _class
         XCB_COPY_FROM_PARENT,          // visual
         0,                             // value_mask
         nullptr                        // value_list
     );
 
     xcb_size_hints_t sizeHints = {};
     xcb_icccm_size_hints_set_position(&sizeHints, 1, geometry.x(), geometry.y());
     xcb_icccm_size_hints_set_size(&sizeHints, 1, geometry.width(), geometry.height());
     xcb_icccm_set_wm_normal_hints(conn, wid, &sizeHints);
 
     if (leaderWid == XCB_WINDOW_NONE) {
         leaderWid = wid;
     }
 
     xcb_change_property(
         conn,                    // c
         XCB_PROP_MODE_REPLACE,   // mode
         wid,                     // window
         atoms->wm_client_leader, // property
         XCB_ATOM_WINDOW,         // type
         32,                      // format
         1,                       // data_len
         &leaderWid               // data
     );
 
     return wid;
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *c) {
         xcb_disconnect(c);
     }
 };
 
 void StackingOrderTest::testGroupTransientIsAboveWindowGroup()
 {
     // This test verifies that group transients are always above other
     // window group members.
 
     const QRect geometry = QRect(0, 0, 128, 128);
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
         xcb_connect(nullptr, nullptr));
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
 
     // Create the group leader.
     xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
     xcb_map_window(conn.data(), leaderWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *leader = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(leader);
     QVERIFY(leader->isActive());
     QCOMPARE(leader->windowId(), leaderWid);
     QVERIFY(!leader->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader}));
 
     // Create another group member.
     windowCreatedSpy.clear();
     xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member1Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member1 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member1);
     QVERIFY(member1->isActive());
     QCOMPARE(member1->windowId(), member1Wid);
     QCOMPARE(member1->group(), leader->group());
     QVERIFY(!member1->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1}));
 
     // Create yet another group member.
     windowCreatedSpy.clear();
     xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member2Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member2);
     QVERIFY(member2->isActive());
     QCOMPARE(member2->windowId(), member2Wid);
     QCOMPARE(member2->group(), leader->group());
     QVERIFY(!member2->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2}));
 
     // Create a group transient.
     windowCreatedSpy.clear();
     xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
 
     // Currently, we have some weird bug workaround: if a group transient
     // is a non-modal dialog, then it won't be kept above its window group.
     // We need to explicitly specify window type, otherwise the window type
     // will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
     // for before (the EWMH spec says to do that).
     xcb_atom_t net_wm_window_type = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
     xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
     xcb_change_property(
         conn.data(),               // c
         XCB_PROP_MODE_REPLACE,     // mode
         transientWid,              // window
         net_wm_window_type,        // property
         XCB_ATOM_ATOM,             // type
         32,                        // format
         1,                         // data_len
         &net_wm_window_type_normal // data
     );
 
     xcb_map_window(conn.data(), transientWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *transient = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(transient);
     QVERIFY(transient->isActive());
     QCOMPARE(transient->windowId(), transientWid);
     QCOMPARE(transient->group(), leader->group());
     QVERIFY(transient->isTransient());
     QVERIFY(transient->groupTransient());
     QVERIFY(!transient->isDialog()); // See above why
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 
     // If we activate any member of the window group, the transient will be above it.
     workspace()->activateClient(leader);
     QTRY_VERIFY(leader->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, member2, leader, transient}));
 
     workspace()->activateClient(member1);
     QTRY_VERIFY(member1->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member2, leader, member1, transient}));
 
     workspace()->activateClient(member2);
     QTRY_VERIFY(member2->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 
     workspace()->activateClient(transient);
     QTRY_VERIFY(transient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 }
 
 void StackingOrderTest::testRaiseGroupTransient()
 {
     const QRect geometry = QRect(0, 0, 128, 128);
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
         xcb_connect(nullptr, nullptr));
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
 
     // Create the group leader.
     xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
     xcb_map_window(conn.data(), leaderWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *leader = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(leader);
     QVERIFY(leader->isActive());
     QCOMPARE(leader->windowId(), leaderWid);
     QVERIFY(!leader->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader}));
 
     // Create another group member.
     windowCreatedSpy.clear();
     xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member1Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member1 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member1);
     QVERIFY(member1->isActive());
     QCOMPARE(member1->windowId(), member1Wid);
     QCOMPARE(member1->group(), leader->group());
     QVERIFY(!member1->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1}));
 
     // Create yet another group member.
     windowCreatedSpy.clear();
     xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member2Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member2);
     QVERIFY(member2->isActive());
     QCOMPARE(member2->windowId(), member2Wid);
     QCOMPARE(member2->group(), leader->group());
     QVERIFY(!member2->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2}));
 
     // Create a group transient.
     windowCreatedSpy.clear();
     xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
 
     // Currently, we have some weird bug workaround: if a group transient
     // is a non-modal dialog, then it won't be kept above its window group.
     // We need to explicitly specify window type, otherwise the window type
     // will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
     // for before (the EWMH spec says to do that).
     xcb_atom_t net_wm_window_type = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
     xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
     xcb_change_property(
         conn.data(),               // c
         XCB_PROP_MODE_REPLACE,     // mode
         transientWid,              // window
         net_wm_window_type,        // property
         XCB_ATOM_ATOM,             // type
         32,                        // format
         1,                         // data_len
         &net_wm_window_type_normal // data
     );
 
     xcb_map_window(conn.data(), transientWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *transient = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(transient);
     QVERIFY(transient->isActive());
     QCOMPARE(transient->windowId(), transientWid);
     QCOMPARE(transient->group(), leader->group());
     QVERIFY(transient->isTransient());
     QVERIFY(transient->groupTransient());
     QVERIFY(!transient->isDialog()); // See above why
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 
     // Create a Wayland client that is not a member of the window group.
     KWayland::Client::Surface *anotherSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(anotherSurface);
     KWayland::Client::XdgShellSurface *anotherShellSurface =
         Test::createXdgShellStableSurface(anotherSurface, anotherSurface);
     QVERIFY(anotherShellSurface);
-    XdgShellClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
+    AbstractClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
     QVERIFY(anotherClient);
     QVERIFY(anotherClient->isActive());
     QVERIFY(!anotherClient->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient, anotherClient}));
 
     // If we activate the leader, then only it and the transient have to be raised.
     workspace()->activateClient(leader);
     QTRY_VERIFY(leader->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, member2, anotherClient, leader, transient}));
 
     // If another member of the window group is activated, then the transient will
     // be above that member and the leader.
     workspace()->activateClient(member2);
     QTRY_VERIFY(member2->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, anotherClient, leader, member2, transient}));
 
     // FIXME: If we activate the transient, only it will be raised.
     workspace()->activateClient(anotherClient);
     QTRY_VERIFY(anotherClient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, leader, member2, transient, anotherClient}));
 
     workspace()->activateClient(transient);
     QTRY_VERIFY(transient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, leader, member2, anotherClient, transient}));
 }
 
 void StackingOrderTest::testDeletedGroupTransient()
 {
     // This test verifies that deleted group transients are kept above their
     // old window groups.
 
     const QRect geometry = QRect(0, 0, 128, 128);
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
         xcb_connect(nullptr, nullptr));
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
 
     // Create the group leader.
     xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
     xcb_map_window(conn.data(), leaderWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *leader = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(leader);
     QVERIFY(leader->isActive());
     QCOMPARE(leader->windowId(), leaderWid);
     QVERIFY(!leader->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader}));
 
     // Create another group member.
     windowCreatedSpy.clear();
     xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member1Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member1 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member1);
     QVERIFY(member1->isActive());
     QCOMPARE(member1->windowId(), member1Wid);
     QCOMPARE(member1->group(), leader->group());
     QVERIFY(!member1->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1}));
 
     // Create yet another group member.
     windowCreatedSpy.clear();
     xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member2Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member2);
     QVERIFY(member2->isActive());
     QCOMPARE(member2->windowId(), member2Wid);
     QCOMPARE(member2->group(), leader->group());
     QVERIFY(!member2->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2}));
 
     // Create a group transient.
     windowCreatedSpy.clear();
     xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
 
     // Currently, we have some weird bug workaround: if a group transient
     // is a non-modal dialog, then it won't be kept above its window group.
     // We need to explicitly specify window type, otherwise the window type
     // will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
     // for before (the EWMH spec says to do that).
     xcb_atom_t net_wm_window_type = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
     xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
         QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
     xcb_change_property(
         conn.data(),               // c
         XCB_PROP_MODE_REPLACE,     // mode
         transientWid,              // window
         net_wm_window_type,        // property
         XCB_ATOM_ATOM,             // type
         32,                        // format
         1,                         // data_len
         &net_wm_window_type_normal // data
     );
 
     xcb_map_window(conn.data(), transientWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *transient = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(transient);
     QVERIFY(transient->isActive());
     QCOMPARE(transient->windowId(), transientWid);
     QCOMPARE(transient->group(), leader->group());
     QVERIFY(transient->isTransient());
     QVERIFY(transient->groupTransient());
     QVERIFY(!transient->isDialog()); // See above why
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 
     // Unmap the transient.
     connect(transient, &X11Client::windowClosed, this,
         [](Toplevel *toplevel, Deleted *deleted) {
             Q_UNUSED(toplevel)
             deleted->refWindow();
         }
     );
 
     QSignalSpy windowClosedSpy(transient, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(conn.data(), transientWid);
     xcb_flush(conn.data());
     QVERIFY(windowClosedSpy.wait());
 
     QScopedPointer<Deleted, WindowUnrefDeleter> deletedTransient(
         windowClosedSpy.first().at(1).value<Deleted *>());
     QVERIFY(deletedTransient.data());
 
     // The transient has to be above each member of the window group.
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, deletedTransient.data()}));
 }
 
 void StackingOrderTest::testDontKeepAboveNonModalDialogGroupTransients()
 {
     // Bug 76026
 
     const QRect geometry = QRect(0, 0, 128, 128);
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
         xcb_connect(nullptr, nullptr));
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
 
     // Create the group leader.
     xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
     xcb_map_window(conn.data(), leaderWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *leader = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(leader);
     QVERIFY(leader->isActive());
     QCOMPARE(leader->windowId(), leaderWid);
     QVERIFY(!leader->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader}));
 
     // Create another group member.
     windowCreatedSpy.clear();
     xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member1Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member1 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member1);
     QVERIFY(member1->isActive());
     QCOMPARE(member1->windowId(), member1Wid);
     QCOMPARE(member1->group(), leader->group());
     QVERIFY(!member1->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1}));
 
     // Create yet another group member.
     windowCreatedSpy.clear();
     xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_map_window(conn.data(), member2Wid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *member2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(member2);
     QVERIFY(member2->isActive());
     QCOMPARE(member2->windowId(), member2Wid);
     QCOMPARE(member2->group(), leader->group());
     QVERIFY(!member2->isTransient());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2}));
 
     // Create a group transient.
     windowCreatedSpy.clear();
     xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
     xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
     xcb_map_window(conn.data(), transientWid);
     xcb_flush(conn.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *transient = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(transient);
     QVERIFY(transient->isActive());
     QCOMPARE(transient->windowId(), transientWid);
     QCOMPARE(transient->group(), leader->group());
     QVERIFY(transient->isTransient());
     QVERIFY(transient->groupTransient());
     QVERIFY(transient->isDialog());
     QVERIFY(!transient->isModal());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 
     workspace()->activateClient(leader);
     QTRY_VERIFY(leader->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member1, member2, transient, leader}));
 
     workspace()->activateClient(member1);
     QTRY_VERIFY(member1->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{member2, transient, leader, member1}));
 
     workspace()->activateClient(member2);
     QTRY_VERIFY(member2->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{transient, leader, member1, member2}));
 
     workspace()->activateClient(transient);
     QTRY_VERIFY(transient->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{leader, member1, member2, transient}));
 }
 
 void StackingOrderTest::testKeepAbove()
 {
     // This test verifies that "keep-above" windows are kept above other windows.
 
     // Create the first client.
     KWayland::Client::Surface *clientASurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(clientASurface);
     KWayland::Client::XdgShellSurface *clientAShellSurface =
         Test::createXdgShellStableSurface(clientASurface, clientASurface);
     QVERIFY(clientAShellSurface);
-    XdgShellClient *clientA = Test::renderAndWaitForShown(clientASurface, QSize(128, 128), Qt::green);
+    AbstractClient *clientA = Test::renderAndWaitForShown(clientASurface, QSize(128, 128), Qt::green);
     QVERIFY(clientA);
     QVERIFY(clientA->isActive());
     QVERIFY(!clientA->keepAbove());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientA}));
 
     // Create the second client.
     KWayland::Client::Surface *clientBSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(clientBSurface);
     KWayland::Client::XdgShellSurface *clientBShellSurface =
         Test::createXdgShellStableSurface(clientBSurface, clientBSurface);
     QVERIFY(clientBShellSurface);
-    XdgShellClient *clientB = Test::renderAndWaitForShown(clientBSurface, QSize(128, 128), Qt::green);
+    AbstractClient *clientB = Test::renderAndWaitForShown(clientBSurface, QSize(128, 128), Qt::green);
     QVERIFY(clientB);
     QVERIFY(clientB->isActive());
     QVERIFY(!clientB->keepAbove());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientA, clientB}));
 
     // Go to the initial test position.
     workspace()->activateClient(clientA);
     QTRY_VERIFY(clientA->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientB, clientA}));
 
     // Set the "keep-above" flag on the client B, it should go above other clients.
     {
         StackingUpdatesBlocker blocker(workspace());
         clientB->setKeepAbove(true);
     }
 
     QVERIFY(clientB->keepAbove());
     QVERIFY(!clientB->isActive());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientA, clientB}));
 }
 
 void StackingOrderTest::testKeepBelow()
 {
     // This test verifies that "keep-below" windows are kept below other windows.
 
     // Create the first client.
     KWayland::Client::Surface *clientASurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(clientASurface);
     KWayland::Client::XdgShellSurface *clientAShellSurface =
         Test::createXdgShellStableSurface(clientASurface, clientASurface);
     QVERIFY(clientAShellSurface);
-    XdgShellClient *clientA = Test::renderAndWaitForShown(clientASurface, QSize(128, 128), Qt::green);
+    AbstractClient *clientA = Test::renderAndWaitForShown(clientASurface, QSize(128, 128), Qt::green);
     QVERIFY(clientA);
     QVERIFY(clientA->isActive());
     QVERIFY(!clientA->keepBelow());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientA}));
 
     // Create the second client.
     KWayland::Client::Surface *clientBSurface =
         Test::createSurface(Test::waylandCompositor());
     QVERIFY(clientBSurface);
     KWayland::Client::XdgShellSurface *clientBShellSurface =
         Test::createXdgShellStableSurface(clientBSurface, clientBSurface);
     QVERIFY(clientBShellSurface);
-    XdgShellClient *clientB = Test::renderAndWaitForShown(clientBSurface, QSize(128, 128), Qt::green);
+    AbstractClient *clientB = Test::renderAndWaitForShown(clientBSurface, QSize(128, 128), Qt::green);
     QVERIFY(clientB);
     QVERIFY(clientB->isActive());
     QVERIFY(!clientB->keepBelow());
 
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientA, clientB}));
 
     // Set the "keep-below" flag on the client B, it should go below other clients.
     {
         StackingUpdatesBlocker blocker(workspace());
         clientB->setKeepBelow(true);
     }
 
     QVERIFY(clientB->isActive());
     QVERIFY(clientB->keepBelow());
     QCOMPARE(workspace()->stackingOrder(), (QList<Toplevel *>{clientB, clientA}));
 }
 
 WAYLANDTEST_MAIN(StackingOrderTest)
 #include "stacking_order_test.moc"
diff --git a/autotests/integration/struts_test.cpp b/autotests/integration/struts_test.cpp
index 8a2a7d990..5ef2ad5af 100644
--- a/autotests/integration/struts_test.cpp
+++ b/autotests/integration/struts_test.cpp
@@ -1,967 +1,965 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 #include <KDecoration2/Decoration>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_struts-0");
 
 class StrutsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testWaylandStruts_data();
     void testWaylandStruts();
     void testMoveWaylandPanel();
     void testWaylandMobilePanel();
     void testX11Struts_data();
     void testX11Struts();
     void test363804();
     void testLeftScreenSmallerBottomAligned();
     void testWindowMoveWithPanelBetweenScreens();
 
 private:
     KWayland::Client::Compositor *m_compositor = nullptr;
     KWayland::Client::PlasmaShell *m_plasmaShell = nullptr;
 };
 
 void StrutsTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // set custom config which disables the Outline
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup group = config->group("Outline");
     group.writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
     group.sync();
 
     kwinApp()->setConfig(config);
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void StrutsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::PlasmaShell));
     m_compositor = Test::waylandCompositor();
     m_plasmaShell = Test::waylandPlasmaShell();
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
     QVERIFY(waylandServer()->clients().isEmpty());
 }
 
 void StrutsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void StrutsTest::testWaylandStruts_data()
 {
     QTest::addColumn<QVector<QRect>>("windowGeometries");
     QTest::addColumn<QRect>("screen0Maximized");
     QTest::addColumn<QRect>("screen1Maximized");
     QTest::addColumn<QRect>("workArea");
     QTest::addColumn<QRegion>("restrictedMoveArea");
 
     QTest::newRow("bottom/0") << QVector<QRect>{QRect(0, 992, 1280, 32)}    << QRect(0, 0, 1280, 992)   << QRect(1280, 0, 1280, 1024) << QRect(0, 0, 2560, 992) << QRegion(0, 992, 1280, 32);
     QTest::newRow("bottom/1") << QVector<QRect>{QRect(1280, 992, 1280, 32)} << QRect(0, 0, 1280, 1024)  << QRect(1280, 0, 1280, 992)  << QRect(0, 0, 2560, 992) << QRegion(1280, 992, 1280, 32);
     QTest::newRow("top/0")    << QVector<QRect>{QRect(0, 0, 1280, 32)}      << QRect(0, 32, 1280, 992)  << QRect(1280, 0, 1280, 1024) << QRect(0, 32, 2560, 992) << QRegion(0, 0, 1280, 32);
     QTest::newRow("top/1")    << QVector<QRect>{QRect(1280, 0, 1280, 32)}   << QRect(0, 0, 1280, 1024)  << QRect(1280, 32, 1280, 992) << QRect(0, 32, 2560, 992) << QRegion(1280, 0, 1280, 32);
     QTest::newRow("left/0")   << QVector<QRect>{QRect(0, 0, 32, 1024)}      << QRect(32, 0, 1248, 1024) << QRect(1280, 0, 1280, 1024) << QRect(32, 0, 2528, 1024) << QRegion(0, 0, 32, 1024);
     QTest::newRow("left/1")   << QVector<QRect>{QRect(1280, 0, 32, 1024)}   << QRect(0, 0, 1280, 1024)  << QRect(1312, 0, 1248, 1024) << QRect(0, 0, 2560, 1024) << QRegion(1280, 0, 32, 1024);
     QTest::newRow("right/0")  << QVector<QRect>{QRect(1248, 0, 32, 1024)}   << QRect(0, 0, 1248, 1024)  << QRect(1280, 0, 1280, 1024) << QRect(0, 0, 2560, 1024) << QRegion(1248, 0, 32, 1024);
     QTest::newRow("right/1")  << QVector<QRect>{QRect(2528, 0, 32, 1024)}   << QRect(0, 0, 1280, 1024)  << QRect(1280, 0, 1248, 1024) << QRect(0, 0, 2528, 1024) << QRegion(2528, 0, 32, 1024);
 
     // same with partial panels not covering the whole area
     QTest::newRow("part bottom/0") << QVector<QRect>{QRect(100, 992, 1080, 32)}  << QRect(0, 0, 1280, 992)   << QRect(1280, 0, 1280, 1024) << QRect(0, 0, 2560, 992) << QRegion(100, 992, 1080, 32);
     QTest::newRow("part bottom/1") << QVector<QRect>{QRect(1380, 992, 1080, 32)} << QRect(0, 0, 1280, 1024)  << QRect(1280, 0, 1280, 992)  << QRect(0, 0, 2560, 992) << QRegion(1380, 992, 1080, 32);
     QTest::newRow("part top/0")    << QVector<QRect>{QRect(100, 0, 1080, 32)}    << QRect(0, 32, 1280, 992)  << QRect(1280, 0, 1280, 1024) << QRect(0, 32, 2560, 992) << QRegion(100, 0, 1080, 32);
     QTest::newRow("part top/1")    << QVector<QRect>{QRect(1380, 0, 1080, 32)}   << QRect(0, 0, 1280, 1024)  << QRect(1280, 32, 1280, 992) << QRect(0, 32, 2560, 992) << QRegion(1380, 0, 1080, 32);
     QTest::newRow("part left/0")   << QVector<QRect>{QRect(0, 100, 32, 824)}     << QRect(32, 0, 1248, 1024) << QRect(1280, 0, 1280, 1024) << QRect(32, 0, 2528, 1024) << QRegion(0, 100, 32, 824);
     QTest::newRow("part left/1")   << QVector<QRect>{QRect(1280, 100, 32, 824)}  << QRect(0, 0, 1280, 1024)  << QRect(1312, 0, 1248, 1024) << QRect(0, 0, 2560, 1024) << QRegion(1280, 100, 32, 824);
     QTest::newRow("part right/0")  << QVector<QRect>{QRect(1248, 100, 32, 824)}  << QRect(0, 0, 1248, 1024)  << QRect(1280, 0, 1280, 1024) << QRect(0, 0, 2560, 1024) << QRegion(1248, 100, 32, 824);
     QTest::newRow("part right/1")  << QVector<QRect>{QRect(2528, 100, 32, 824)}  << QRect(0, 0, 1280, 1024)  << QRect(1280, 0, 1248, 1024) << QRect(0, 0, 2528, 1024) << QRegion(2528, 100, 32, 824);
 
     // multiple panels
     QTest::newRow("two bottom panels") << QVector<QRect>{QRect(100, 992, 1080, 32), QRect(1380, 984, 1080, 40)} << QRect(0, 0, 1280, 992) << QRect(1280, 0, 1280, 984) << QRect(0, 0, 2560, 984) << QRegion(100, 992, 1080, 32).united(QRegion(1380, 984, 1080, 40));
     QTest::newRow("two left panels") << QVector<QRect>{QRect(0, 10, 32, 390), QRect(0, 450, 40, 100)} << QRect(40, 0, 1240, 1024) << QRect(1280, 0, 1280, 1024) << QRect(40, 0, 2520, 1024) << QRegion(0, 10, 32, 390).united(QRegion(0, 450, 40, 100));
 }
 
 void StrutsTest::testWaylandStruts()
 {
     // this test verifies that struts on Wayland panels are handled correctly
     using namespace KWayland::Client;
     // no, struts yet
     QVERIFY(waylandServer()->clients().isEmpty());
     // first screen
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     // second screen
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     // combined
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->clientArea(FullArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->restrictedMoveArea(-1), QRegion());
 
     QFETCH(QVector<QRect>, windowGeometries);
     // create the panels
-    QHash<Surface*, XdgShellClient *> clients;
+    QHash<Surface*, AbstractClient *> clients;
     for (auto it = windowGeometries.constBegin(), end = windowGeometries.constEnd(); it != end; it++) {
         const QRect windowGeometry = *it;
         Surface *surface = Test::createSurface(m_compositor);
         XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface, Test::CreationSetup::CreateOnly);
         PlasmaShellSurface *plasmaSurface = m_plasmaShell->createSurface(surface, surface);
         plasmaSurface->setPosition(windowGeometry.topLeft());
         plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
         Test::initXdgShellSurface(surface, shellSurface);
 
         // map the window
         auto c = Test::renderAndWaitForShown(surface, windowGeometry.size(), Qt::red, QImage::Format_RGB32);
 
         QVERIFY(c);
         QVERIFY(!c->isActive());
         QCOMPARE(c->frameGeometry(), windowGeometry);
         QVERIFY(c->isDock());
         QVERIFY(c->hasStrut());
         clients.insert(surface, c);
     }
 
     // some props are independent of struts - those first
     // screen 0
     QCOMPARE(workspace()->clientArea(MovementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     // screen 1
     QCOMPARE(workspace()->clientArea(MovementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     // combined
     QCOMPARE(workspace()->clientArea(FullArea, 0, 1), QRect(0, 0, 2560, 1024));
 
     // now verify the actual updated client areas
     QTEST(workspace()->clientArea(PlacementArea, 0, 1), "screen0Maximized");
     QTEST(workspace()->clientArea(MaximizeArea, 0, 1), "screen0Maximized");
     QTEST(workspace()->clientArea(PlacementArea, 1, 1), "screen1Maximized");
     QTEST(workspace()->clientArea(MaximizeArea, 1, 1), "screen1Maximized");
     QTEST(workspace()->clientArea(WorkArea, 0, 1), "workArea");
     QTEST(workspace()->restrictedMoveArea(-1), "restrictedMoveArea");
 
     // delete all surfaces
     for (auto it = clients.begin(); it != clients.end(); it++) {
         QSignalSpy destroyedSpy(it.value(), &QObject::destroyed);
         QVERIFY(destroyedSpy.isValid());
         delete it.key();
         QVERIFY(destroyedSpy.wait());
     }
     QCOMPARE(workspace()->restrictedMoveArea(-1), QRegion());
 }
 
 void StrutsTest::testMoveWaylandPanel()
 {
     // this test verifies that repositioning a Wayland panel updates the client area
     using namespace KWayland::Client;
     const QRect windowGeometry(0, 1000, 1280, 24);
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     plasmaSurface->setPosition(windowGeometry.topLeft());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     Test::initXdgShellSurface(surface.data(), shellSurface.data());
 
     // map the window
     auto c = Test::renderAndWaitForShown(surface.data(), windowGeometry.size(), Qt::red, QImage::Format_RGB32);
     QVERIFY(c);
     QVERIFY(!c->isActive());
     QCOMPARE(c->frameGeometry(), windowGeometry);
     QVERIFY(c->isDock());
     QVERIFY(c->hasStrut());
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 0, 1280, 1000));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 0, 1280, 1000));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 2560, 1000));
 
-    QSignalSpy frameGeometryChangedSpy(c, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     plasmaSurface->setPosition(QPoint(1280, 1000));
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(c->frameGeometry(), QRect(1280, 1000, 1280, 24));
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1000));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1000));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 2560, 1000));
 }
 
 void StrutsTest::testWaylandMobilePanel()
 {
     using namespace KWayland::Client;
 
     //First enable maxmizing policy
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("Placement", "Maximizing");
     group.sync();
     workspace()->slotReconfigure();
 
     // create first top panel
     const QRect windowGeometry(0, 0, 1280, 60);
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<PlasmaShellSurface> plasmaSurface(m_plasmaShell->createSurface(surface.data()));
     plasmaSurface->setPosition(windowGeometry.topLeft());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     Test::initXdgShellSurface(surface.data(), shellSurface.data());
 
     // map the first panel
     auto c = Test::renderAndWaitForShown(surface.data(), windowGeometry.size(), Qt::red, QImage::Format_RGB32);
     QVERIFY(c);
     QVERIFY(!c->isActive());
     QCOMPARE(c->frameGeometry(), windowGeometry);
     QVERIFY(c->isDock());
     QVERIFY(c->hasStrut());
 
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 60, 1280, 964));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 60, 1280, 964));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 60, 2560, 964));
 
     // create another bottom panel
     const QRect windowGeometry2(0, 874, 1280, 150);
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data(), surface2.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<PlasmaShellSurface> plasmaSurface2(m_plasmaShell->createSurface(surface2.data()));
     plasmaSurface2->setPosition(windowGeometry2.topLeft());
     plasmaSurface2->setRole(PlasmaShellSurface::Role::Panel);
     Test::initXdgShellSurface(surface2.data(), shellSurface2.data());
 
     auto c1 = Test::renderAndWaitForShown(surface2.data(), windowGeometry2.size(), Qt::blue, QImage::Format_RGB32);
 
     QVERIFY(c1);
     QVERIFY(!c1->isActive());
     QCOMPARE(c1->frameGeometry(), windowGeometry2);
     QVERIFY(c1->isDock());
     QVERIFY(c1->hasStrut());
 
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 60, 1280, 814));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 60, 1280, 814));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 60, 2560, 814));
 
     // Destroy test clients.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     shellSurface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(c1));
 }
 
 void StrutsTest::testX11Struts_data()
 {
     QTest::addColumn<QRect>("windowGeometry");
     QTest::addColumn<int>("leftStrut");
     QTest::addColumn<int>("rightStrut");
     QTest::addColumn<int>("topStrut");
     QTest::addColumn<int>("bottomStrut");
     QTest::addColumn<int>("leftStrutStart");
     QTest::addColumn<int>("leftStrutEnd");
     QTest::addColumn<int>("rightStrutStart");
     QTest::addColumn<int>("rightStrutEnd");
     QTest::addColumn<int>("topStrutStart");
     QTest::addColumn<int>("topStrutEnd");
     QTest::addColumn<int>("bottomStrutStart");
     QTest::addColumn<int>("bottomStrutEnd");
     QTest::addColumn<QRect>("screen0Maximized");
     QTest::addColumn<QRect>("screen1Maximized");
     QTest::addColumn<QRect>("workArea");
     QTest::addColumn<QRegion>("restrictedMoveArea");
 
     QTest::newRow("bottom panel/no strut") << QRect(0, 980, 1280, 44)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("bottom panel/strut") << QRect(0, 980, 1280, 44)
                                         << 0 << 0 << 0 << 44
                                         << 0 << 0
                                         << 0 << 0
                                         << 0 << 0
                                         << 0 << 1279
                                         << QRect(0, 0, 1280, 980)
                                         << QRect(1280, 0, 1280, 1024)
                                         << QRect(0, 0, 2560, 980)
                                         << QRegion(0, 980, 1279, 44);
     QTest::newRow("top panel/no strut") << QRect(0, 0, 1280, 44)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("top panel/strut") << QRect(0, 0, 1280, 44)
                                            << 0 << 0 << 44 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 1279
                                            << 0 << 0
                                            << QRect(0, 44, 1280, 980)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 44, 2560, 980)
                                            << QRegion(0, 0, 1279, 44);
     QTest::newRow("left panel/no strut") << QRect(0, 0, 60, 1024)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("left panel/strut") << QRect(0, 0, 60, 1024)
                                            << 60 << 0 << 0 << 0
                                            << 0 << 1023
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(60, 0, 1220, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(60, 0, 2500, 1024)
                                            << QRegion(0, 0, 60, 1023);
     QTest::newRow("right panel/no strut") << QRect(1220, 0, 60, 1024)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("right panel/strut") << QRect(1220, 0, 60, 1024)
                                            << 0 << 1340 << 0 << 0
                                            << 0 << 0
                                            << 0 << 1023
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1220, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion(1220, 0, 60, 1023);
     // second screen
     QTest::newRow("bottom panel 1/no strut") << QRect(1280, 980, 1280, 44)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("bottom panel 1/strut") << QRect(1280, 980, 1280, 44)
                                            << 0 << 0 << 0 << 44
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 1280 << 2559
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 980)
                                            << QRect(0, 0, 2560, 980)
                                            << QRegion(1280, 980, 1279, 44);
     QTest::newRow("top panel 1/no strut") << QRect(1280, 0, 1280, 44)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("top panel 1 /strut") << QRect(1280, 0, 1280, 44)
                                            << 0 << 0 << 44 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 1280 << 2559
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 44, 1280, 980)
                                            << QRect(0, 44, 2560, 980)
                                            << QRegion(1280, 0, 1279, 44);
     QTest::newRow("left panel 1/no strut") << QRect(1280, 0, 60, 1024)
                                            << 0 << 0 << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion();
     QTest::newRow("left panel 1/strut") << QRect(1280, 0, 60, 1024)
                                            << 1340 << 0 << 0 << 0
                                            << 0 << 1023
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1340, 0, 1220, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion(1280, 0, 60, 1023);
     // invalid struts
     QTest::newRow("bottom panel/ invalid strut") << QRect(0, 980, 1280, 44)
                                         << 1280 << 0 << 0 << 44
                                         << 980 << 1024
                                         << 0 << 0
                                         << 0 << 0
                                         << 0 << 1279
                                         << QRect(0, 0, 1280, 1024)
                                         << QRect(1280, 0, 1280, 1024)
                                         << QRect(0, 0, 2560, 1024)
                                         << QRegion(0, 980, 1280, 44);
     QTest::newRow("top panel/ invalid strut") << QRect(0, 0, 1280, 44)
                                            << 1280 << 0 << 44 << 0
                                            << 0 << 44
                                            << 0 << 0
                                            << 0 << 1279
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion(0, 0, 1280, 44);
     QTest::newRow("top panel/invalid strut 2") << QRect(0, 0, 1280, 44)
                                            << 0 << 0 << 1024 << 0
                                            << 0 << 0
                                            << 0 << 0
                                            << 0 << 1279
                                            << 0 << 0
                                            << QRect(0, 0, 1280, 1024)
                                            << QRect(1280, 0, 1280, 1024)
                                            << QRect(0, 0, 2560, 1024)
                                            << QRegion(0, 0, 1279, 1024);
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void StrutsTest::testX11Struts()
 {
     // this test verifies that struts are applied correctly for X11 windows
 
     // no, struts yet
     // first screen
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     // second screen
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     // combined
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->clientArea(FullArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->restrictedMoveArea(-1), QRegion());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     QFETCH(QRect, windowGeometry);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     // set the extended strut
     QFETCH(int, leftStrut);
     QFETCH(int, rightStrut);
     QFETCH(int, topStrut);
     QFETCH(int, bottomStrut);
     QFETCH(int, leftStrutStart);
     QFETCH(int, leftStrutEnd);
     QFETCH(int, rightStrutStart);
     QFETCH(int, rightStrutEnd);
     QFETCH(int, topStrutStart);
     QFETCH(int, topStrutEnd);
     QFETCH(int, bottomStrutStart);
     QFETCH(int, bottomStrutEnd);
     NETExtendedStrut strut;
     strut.left_start = leftStrutStart;
     strut.left_end = leftStrutEnd;
     strut.left_width = leftStrut;
     strut.right_start = rightStrutStart;
     strut.right_end = rightStrutEnd;
     strut.right_width = rightStrut;
     strut.top_start = topStrutStart;
     strut.top_end = topStrutEnd;
     strut.top_width = topStrut;
     strut.bottom_start = bottomStrutStart;
     strut.bottom_end = bottomStrutEnd;
     strut.bottom_width = bottomStrut;
     info.setExtendedStrut(strut);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->windowType(), NET::Dock);
     QCOMPARE(client->frameGeometry(), windowGeometry);
 
     // this should have affected the client area
     // some props are independent of struts - those first
     // screen 0
     QCOMPARE(workspace()->clientArea(MovementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     // screen 1
     QCOMPARE(workspace()->clientArea(MovementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     // combined
     QCOMPARE(workspace()->clientArea(FullArea, 0, 1), QRect(0, 0, 2560, 1024));
 
     // now verify the actual updated client areas
     QTEST(workspace()->clientArea(PlacementArea, 0, 1), "screen0Maximized");
     QTEST(workspace()->clientArea(MaximizeArea, 0, 1), "screen0Maximized");
     QTEST(workspace()->clientArea(PlacementArea, 1, 1), "screen1Maximized");
     QTEST(workspace()->clientArea(MaximizeArea, 1, 1), "screen1Maximized");
     QTEST(workspace()->clientArea(WorkArea, 0, 1), "workArea");
     QTEST(workspace()->restrictedMoveArea(-1), "restrictedMoveArea");
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 
     // now struts should be removed again
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 0, 1), QRect(0, 0, 1280, 1024));
     // second screen
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MovementArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(MaximizeFullArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(FullScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     QCOMPARE(workspace()->clientArea(ScreenArea, 1, 1), QRect(1280, 0, 1280, 1024));
     // combined
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->clientArea(FullArea, 0, 1), QRect(0, 0, 2560, 1024));
     QCOMPARE(workspace()->restrictedMoveArea(-1), QRegion());
 }
 
 void StrutsTest::test363804()
 {
     // this test verifies the condition described in BUG 363804
     // two screens in a vertical setup, aligned to right border with panel on the bottom screen
     const QVector<QRect> geometries{QRect(0, 0, 1920, 1080), QRect(554, 1080, 1366, 768)};
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 2),
                               Q_ARG(QVector<QRect>, geometries));
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
     QCOMPARE(screens()->geometry(), QRect(0, 0, 1920, 1848));
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry(554, 1812, 1366, 36);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     NETExtendedStrut strut;
     strut.left_start = 0;
     strut.left_end = 0;
     strut.left_width = 0;
     strut.right_start = 0;
     strut.right_end = 0;
     strut.right_width = 0;
     strut.top_start = 0;
     strut.top_end = 0;
     strut.top_width = 0;
     strut.bottom_start = 554;
     strut.bottom_end = 1919;
     strut.bottom_width = 36;
     info.setExtendedStrut(strut);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->windowType(), NET::Dock);
     QCOMPARE(client->frameGeometry(), windowGeometry);
 
     // now verify the actual updated client areas
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), geometries.at(0));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), geometries.at(0));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(554, 1080, 1366, 732));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(554, 1080, 1366, 732));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 1920, 1812));
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void StrutsTest::testLeftScreenSmallerBottomAligned()
 {
     // this test verifies a two screen setup with the left screen smaller than the right and bottom aligned
     // the panel is on the top of the left screen, thus not at 0/0
     // what this test in addition tests is whether a window larger than the left screen is not placed into
     // the dead area
     const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 2),
                               Q_ARG(QVector<QRect>, geometries));
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
     QCOMPARE(screens()->geometry(), QRect(0, 0, 3046, 1050));
 
     // create the panel
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry(0, 282, 1366, 24);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     NETExtendedStrut strut;
     strut.left_start = 0;
     strut.left_end = 0;
     strut.left_width = 0;
     strut.right_start = 0;
     strut.right_end = 0;
     strut.right_width = 0;
     strut.top_start = 0;
     strut.top_end = 1365;
     strut.top_width = 306;
     strut.bottom_start = 0;
     strut.bottom_end = 0;
     strut.bottom_width = 0;
     info.setExtendedStrut(strut);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->windowType(), NET::Dock);
     QCOMPARE(client->frameGeometry(), windowGeometry);
 
     // now verify the actual updated client areas
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 306, 1366, 744));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 306, 1366, 744));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), geometries.at(1));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), geometries.at(1));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 3046, 1050));
 
     // now create a window which is larger than screen 0
 
     xcb_window_t w2 = xcb_generate_id(c.data());
     const QRect windowGeometry2(0, 26, 1280, 774);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w2, rootWindow(),
                       windowGeometry2.x(),
                       windowGeometry2.y(),
                       windowGeometry2.width(),
                       windowGeometry2.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints2;
     memset(&hints2, 0, sizeof(hints2));
     xcb_icccm_size_hints_set_min_size(&hints2, 868, 431);
     xcb_icccm_set_wm_normal_hints(c.data(), w2, &hints2);
     xcb_map_window(c.data(), w2);
     xcb_flush(c.data());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client2 = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client2);
     QVERIFY(client2 != client);
     QVERIFY(client2->isDecorated());
     QCOMPARE(client2->frameGeometry(), QRect(0, 306, 1366, 744));
     QCOMPARE(client2->maximizeMode(), KWin::MaximizeFull);
     // destroy window again
     QSignalSpy normalWindowClosedSpy(client2, &X11Client::windowClosed);
     QVERIFY(normalWindowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w2);
     xcb_destroy_window(c.data(), w2);
     xcb_flush(c.data());
     QVERIFY(normalWindowClosedSpy.wait());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     c.reset();
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void StrutsTest::testWindowMoveWithPanelBetweenScreens()
 {
     // this test verifies the condition of BUG
     // when moving a window with decorations in a restricted way it should pass from one screen
     // to the other even if there is a panel in between.
 
     // left screen must be smaller than right screen
     const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 2),
                               Q_ARG(QVector<QRect>, geometries));
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
     QCOMPARE(screens()->geometry(), QRect(0, 0, 3046, 1050));
 
     // create the panel on the right screen, left edge
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry(1366, 0, 24, 1050);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Dock);
     NETExtendedStrut strut;
     strut.left_start = 0;
     strut.left_end = 1050;
     strut.left_width = 1366+24;
     strut.right_start = 0;
     strut.right_end = 0;
     strut.right_width = 0;
     strut.top_start = 0;
     strut.top_end = 0;
     strut.top_width = 0;
     strut.bottom_start = 0;
     strut.bottom_end = 0;
     strut.bottom_width = 0;
     info.setExtendedStrut(strut);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isDecorated());
     QCOMPARE(client->windowType(), NET::Dock);
     QCOMPARE(client->frameGeometry(), windowGeometry);
 
     // now verify the actual updated client areas
     QCOMPARE(workspace()->clientArea(PlacementArea, 0, 1), QRect(0, 282, 1366, 768));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 0, 1), QRect(0, 282, 1366, 768));
     QCOMPARE(workspace()->clientArea(PlacementArea, 1, 1), QRect(1390, 0, 1656, 1050));
     QCOMPARE(workspace()->clientArea(MaximizeArea, 1, 1), QRect(1390, 0, 1656, 1050));
     QCOMPARE(workspace()->clientArea(WorkArea, 0, 1), QRect(0, 0, 3046, 1050));
     QCOMPARE(workspace()->restrictedMoveArea(-1), QRegion(1366, 0, 24, 1050));
 
     // create another window and try to move it
 
     xcb_window_t w2 = xcb_generate_id(c.data());
     const QRect windowGeometry2(1500, 400, 200, 300);
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w2, rootWindow(),
                       windowGeometry2.x(),
                       windowGeometry2.y(),
                       windowGeometry2.width(),
                       windowGeometry2.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints2;
     memset(&hints2, 0, sizeof(hints2));
     xcb_icccm_size_hints_set_position(&hints2, 1, windowGeometry2.x(), windowGeometry2.y());
     xcb_icccm_size_hints_set_min_size(&hints2, 200, 300);
     xcb_icccm_set_wm_normal_hints(c.data(), w2, &hints2);
     xcb_map_window(c.data(), w2);
     xcb_flush(c.data());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client2 = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client2);
     QVERIFY(client2 != client);
     QVERIFY(client2->isDecorated());
     QCOMPARE(client2->clientSize(), QSize(200, 300));
     QCOMPARE(client2->pos(), QPoint(1500, 400));
 
     const QRect origGeo = client2->frameGeometry();
     Cursor::setPos(origGeo.center());
     workspace()->performWindowOperation(client2, Options::MoveOp);
     QTRY_COMPARE(workspace()->moveResizeClient(), client2);
     QVERIFY(client2->isMove());
     // move to next screen - step is 8 pixel, so 800 pixel
     for (int i = 0; i < 100; i++) {
         client2->keyPressEvent(Qt::Key_Left);
         QTest::qWait(50);
     }
     client2->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(client2->isMove(), false);
     QVERIFY(workspace()->moveResizeClient() == nullptr);
     QCOMPARE(client2->frameGeometry(), QRect(origGeo.translated(-800, 0)));
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::StrutsTest)
 #include "struts_test.moc"
diff --git a/autotests/integration/tabbox_test.cpp b/autotests/integration/tabbox_test.cpp
index a7db23eb3..9a84b93f5 100644
--- a/autotests/integration/tabbox_test.cpp
+++ b/autotests/integration/tabbox_test.cpp
@@ -1,256 +1,255 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "input.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "tabbox/tabbox.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 #include <KConfigGroup>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_tabbox-0");
 
 class TabBoxTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMoveForward();
     void testMoveBackward();
     void testCapsLock();
 };
 
 void TabBoxTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     KSharedConfigPtr c = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     c->group("TabBox").writeEntry("ShowTabBox", false);
     c->sync();
     kwinApp()->setConfig(c);
     qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void TabBoxTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(640, 512));
 }
 
 void TabBoxTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TabBoxTest::testCapsLock()
 {
     // this test verifies that Alt+tab works correctly also when Capslock is on
     // bug 368590
 
     // first create three windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto c1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c1);
     QVERIFY(c1->isActive());
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::red);
     QVERIFY(c2);
     QVERIFY(c2->isActive());
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::red);
     QVERIFY(c3);
     QVERIFY(c3->isActive());
 
     // Setup tabbox signal spies
     QSignalSpy tabboxAddedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxAdded);
     QVERIFY(tabboxAddedSpy.isValid());
     QSignalSpy tabboxClosedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxClosed);
     QVERIFY(tabboxClosedSpy.isValid());
 
     // enable capslock
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
 
     // press alt+tab
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier | Qt::AltModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_TAB, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_TAB, timestamp++);
 
     QVERIFY(tabboxAddedSpy.wait());
     QVERIFY(TabBox::TabBox::self()->isGrabbed());
 
     // release alt
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QCOMPARE(tabboxClosedSpy.count(), 1);
     QCOMPARE(TabBox::TabBox::self()->isGrabbed(), false);
 
     // release caps lock
     kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::NoModifier);
     QCOMPARE(tabboxClosedSpy.count(), 1);
     QCOMPARE(TabBox::TabBox::self()->isGrabbed(), false);
     QCOMPARE(workspace()->activeClient(), c2);
 
     surface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(c3));
     surface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(c2));
     surface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(c1));
 }
 
 void TabBoxTest::testMoveForward()
 {
     // this test verifies that Alt+tab works correctly moving forward
 
     // first create three windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto c1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c1);
     QVERIFY(c1->isActive());
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::red);
     QVERIFY(c2);
     QVERIFY(c2->isActive());
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::red);
     QVERIFY(c3);
     QVERIFY(c3->isActive());
 
     // Setup tabbox signal spies
     QSignalSpy tabboxAddedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxAdded);
     QVERIFY(tabboxAddedSpy.isValid());
     QSignalSpy tabboxClosedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxClosed);
     QVERIFY(tabboxClosedSpy.isValid());
 
     // press alt+tab
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::AltModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_TAB, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_TAB, timestamp++);
 
     QVERIFY(tabboxAddedSpy.wait());
     QVERIFY(TabBox::TabBox::self()->isGrabbed());
 
     // release alt
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QCOMPARE(tabboxClosedSpy.count(), 1);
     QCOMPARE(TabBox::TabBox::self()->isGrabbed(), false);
     QCOMPARE(workspace()->activeClient(), c2);
 
     surface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(c3));
     surface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(c2));
     surface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(c1));
 }
 
 void TabBoxTest::testMoveBackward()
 {
     // this test verifies that Alt+Shift+tab works correctly moving backward
 
     // first create three windows
     QScopedPointer<Surface> surface1(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface1(Test::createXdgShellStableSurface(surface1.data()));
     auto c1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c1);
     QVERIFY(c1->isActive());
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::red);
     QVERIFY(c2);
     QVERIFY(c2->isActive());
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::red);
     QVERIFY(c3);
     QVERIFY(c3->isActive());
 
     // Setup tabbox signal spies
     QSignalSpy tabboxAddedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxAdded);
     QVERIFY(tabboxAddedSpy.isValid());
     QSignalSpy tabboxClosedSpy(TabBox::TabBox::self(), &TabBox::TabBox::tabBoxClosed);
     QVERIFY(tabboxClosedSpy.isValid());
 
     // press alt+shift+tab
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::AltModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::AltModifier | Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_TAB, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_TAB, timestamp++);
 
     QVERIFY(tabboxAddedSpy.wait());
     QVERIFY(TabBox::TabBox::self()->isGrabbed());
 
     // release alt
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(tabboxClosedSpy.count(), 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QCOMPARE(tabboxClosedSpy.count(), 1);
     QCOMPARE(TabBox::TabBox::self()->isGrabbed(), false);
     QCOMPARE(workspace()->activeClient(), c1);
 
     surface3.reset();
     QVERIFY(Test::waitForWindowDestroyed(c3));
     surface2.reset();
     QVERIFY(Test::waitForWindowDestroyed(c2));
     surface1.reset();
     QVERIFY(Test::waitForWindowDestroyed(c1));
 }
 
 WAYLANDTEST_MAIN(TabBoxTest)
 #include "tabbox_test.moc"
diff --git a/autotests/integration/test_helpers.cpp b/autotests/integration/test_helpers.cpp
index f403daafb..d42dfb356 100644
--- a/autotests/integration/test_helpers.cpp
+++ b/autotests/integration/test_helpers.cpp
@@ -1,611 +1,611 @@
 /********************************************************************
 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 "kwin_wayland_test.h"
-#include "xdgshellclient.h"
+#include "abstract_client.h"
 #include "screenlockerwatcher.h"
 #include "wayland_server.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/idleinhibit.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/output.h>
 #include <KWayland/Client/subcompositor.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/appmenu.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Server/display.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <QThread>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 using namespace KWayland::Client;
 
 namespace KWin
 {
 namespace Test
 {
 
 static struct {
     ConnectionThread *connection = nullptr;
     EventQueue *queue = nullptr;
     Compositor *compositor = nullptr;
     SubCompositor *subCompositor = nullptr;
     ServerSideDecorationManager *decoration = nullptr;
     ShadowManager *shadowManager = nullptr;
     XdgShell *xdgShellV6 = nullptr;
     XdgShell *xdgShellStable = nullptr;
     ShmPool *shm = nullptr;
     Seat *seat = nullptr;
     PlasmaShell *plasmaShell = nullptr;
     PlasmaWindowManagement *windowManagement = nullptr;
     PointerConstraints *pointerConstraints = nullptr;
     Registry *registry = nullptr;
     QThread *thread = nullptr;
     QVector<Output*> outputs;
     IdleInhibitManager *idleInhibit = nullptr;
     AppMenuManager *appMenu = nullptr;
     XdgDecorationManager *xdgDecoration = nullptr;
 } s_waylandConnection;
 
 bool setupWaylandConnection(AdditionalWaylandInterfaces flags)
 {
     if (s_waylandConnection.connection) {
         return false;
     }
 
     int sx[2];
     if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) < 0) {
         return false;
     }
     KWin::waylandServer()->display()->createClient(sx[0]);
     // setup connection
     s_waylandConnection.connection = new ConnectionThread;
     QSignalSpy connectedSpy(s_waylandConnection.connection, &ConnectionThread::connected);
     if (!connectedSpy.isValid()) {
         return false;
     }
     s_waylandConnection.connection->setSocketFd(sx[1]);
 
     s_waylandConnection.thread = new QThread(kwinApp());
     s_waylandConnection.connection->moveToThread(s_waylandConnection.thread);
     s_waylandConnection.thread->start();
 
     s_waylandConnection.connection->initConnection();
     if (!connectedSpy.wait()) {
         return false;
     }
 
     s_waylandConnection.queue = new EventQueue;
     s_waylandConnection.queue->setup(s_waylandConnection.connection);
     if (!s_waylandConnection.queue->isValid()) {
         return false;
     }
 
     Registry *registry = new Registry;
     s_waylandConnection.registry = registry;
     registry->setEventQueue(s_waylandConnection.queue);
 
     QObject::connect(registry, &Registry::outputAnnounced, [=](quint32 name, quint32 version) {
         auto output = registry->createOutput(name, version, s_waylandConnection.registry);
         s_waylandConnection.outputs << output;
         QObject::connect(output, &Output::removed, [=]() {
             output->deleteLater();
             s_waylandConnection.outputs.removeOne(output);
         });
     });
 
     QSignalSpy allAnnounced(registry, &Registry::interfacesAnnounced);
     if (!allAnnounced.isValid()) {
         return false;
     }
     registry->create(s_waylandConnection.connection);
     if (!registry->isValid()) {
         return false;
     }
     registry->setup();
     if (!allAnnounced.wait()) {
         return false;
     }
 
     s_waylandConnection.compositor = registry->createCompositor(registry->interface(Registry::Interface::Compositor).name, registry->interface(Registry::Interface::Compositor).version);
     if (!s_waylandConnection.compositor->isValid()) {
         return false;
     }
     s_waylandConnection.subCompositor = registry->createSubCompositor(registry->interface(Registry::Interface::SubCompositor).name, registry->interface(Registry::Interface::SubCompositor).version);
     if (!s_waylandConnection.subCompositor->isValid()) {
         return false;
     }
     s_waylandConnection.shm = registry->createShmPool(registry->interface(Registry::Interface::Shm).name, registry->interface(Registry::Interface::Shm).version);
     if (!s_waylandConnection.shm->isValid()) {
         return false;
     }
     s_waylandConnection.xdgShellV6 = registry->createXdgShell(registry->interface(Registry::Interface::XdgShellUnstableV6).name, registry->interface(Registry::Interface::XdgShellUnstableV6).version);
     if (!s_waylandConnection.xdgShellV6->isValid()) {
         return false;
     }
     s_waylandConnection.xdgShellStable = registry->createXdgShell(registry->interface(Registry::Interface::XdgShellStable).name, registry->interface(Registry::Interface::XdgShellStable).version);
     if (!s_waylandConnection.xdgShellStable->isValid()) {
         return false;
     }
     if (flags.testFlag(AdditionalWaylandInterface::Seat)) {
         s_waylandConnection.seat = registry->createSeat(registry->interface(Registry::Interface::Seat).name, registry->interface(Registry::Interface::Seat).version);
         if (!s_waylandConnection.seat->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::ShadowManager)) {
         s_waylandConnection.shadowManager = registry->createShadowManager(registry->interface(Registry::Interface::Shadow).name,
                                                                           registry->interface(Registry::Interface::Shadow).version);
         if (!s_waylandConnection.shadowManager->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::Decoration)) {
         s_waylandConnection.decoration = registry->createServerSideDecorationManager(registry->interface(Registry::Interface::ServerSideDecorationManager).name,
                                                                                     registry->interface(Registry::Interface::ServerSideDecorationManager).version);
         if (!s_waylandConnection.decoration->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::PlasmaShell)) {
         s_waylandConnection.plasmaShell = registry->createPlasmaShell(registry->interface(Registry::Interface::PlasmaShell).name,
                                                                      registry->interface(Registry::Interface::PlasmaShell).version);
         if (!s_waylandConnection.plasmaShell->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::WindowManagement)) {
         s_waylandConnection.windowManagement = registry->createPlasmaWindowManagement(registry->interface(Registry::Interface::PlasmaWindowManagement).name,
                                                                                      registry->interface(Registry::Interface::PlasmaWindowManagement).version);
         if (!s_waylandConnection.windowManagement->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::PointerConstraints)) {
         s_waylandConnection.pointerConstraints = registry->createPointerConstraints(registry->interface(Registry::Interface::PointerConstraintsUnstableV1).name,
                                                                                    registry->interface(Registry::Interface::PointerConstraintsUnstableV1).version);
         if (!s_waylandConnection.pointerConstraints->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::IdleInhibition)) {
         s_waylandConnection.idleInhibit = registry->createIdleInhibitManager(registry->interface(Registry::Interface::IdleInhibitManagerUnstableV1).name,
                                                                             registry->interface(Registry::Interface::IdleInhibitManagerUnstableV1).version);
         if (!s_waylandConnection.idleInhibit->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::AppMenu)) {
         s_waylandConnection.appMenu = registry->createAppMenuManager(registry->interface(Registry::Interface::AppMenu).name, registry->interface(Registry::Interface::AppMenu).version);
         if (!s_waylandConnection.appMenu->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::XdgDecoration)) {
         s_waylandConnection.xdgDecoration = registry->createXdgDecorationManager(registry->interface(Registry::Interface::XdgDecorationUnstableV1).name, registry->interface(Registry::Interface::XdgDecorationUnstableV1).version);
         if (!s_waylandConnection.xdgDecoration->isValid()) {
             return false;
         }
     }
 
     return true;
 }
 
 void destroyWaylandConnection()
 {
     delete s_waylandConnection.compositor;
     s_waylandConnection.compositor = nullptr;
     delete s_waylandConnection.subCompositor;
     s_waylandConnection.subCompositor = nullptr;
     delete s_waylandConnection.windowManagement;
     s_waylandConnection.windowManagement = nullptr;
     delete s_waylandConnection.plasmaShell;
     s_waylandConnection.plasmaShell = nullptr;
     delete s_waylandConnection.decoration;
     s_waylandConnection.decoration = nullptr;
     delete s_waylandConnection.decoration;
     s_waylandConnection.decoration = nullptr;
     delete s_waylandConnection.seat;
     s_waylandConnection.seat = nullptr;
     delete s_waylandConnection.pointerConstraints;
     s_waylandConnection.pointerConstraints = nullptr;
     delete s_waylandConnection.xdgShellV6;
     s_waylandConnection.xdgShellV6 = nullptr;
     delete s_waylandConnection.xdgShellStable;
     s_waylandConnection.xdgShellStable = nullptr;
     delete s_waylandConnection.shadowManager;
     s_waylandConnection.shadowManager = nullptr;
     delete s_waylandConnection.idleInhibit;
     s_waylandConnection.idleInhibit = nullptr;
     delete s_waylandConnection.shm;
     s_waylandConnection.shm = nullptr;
     delete s_waylandConnection.queue;
     s_waylandConnection.queue = nullptr;
     delete s_waylandConnection.registry;
     s_waylandConnection.registry = nullptr;
     delete s_waylandConnection.appMenu;
     s_waylandConnection.appMenu = nullptr;
     delete s_waylandConnection.xdgDecoration;
     s_waylandConnection.xdgDecoration = nullptr;
     if (s_waylandConnection.thread) {
         QSignalSpy spy(s_waylandConnection.connection, &QObject::destroyed);
         s_waylandConnection.connection->deleteLater();
         if (spy.isEmpty()) {
             QVERIFY(spy.wait());
         }
         s_waylandConnection.thread->quit();
         s_waylandConnection.thread->wait();
         delete s_waylandConnection.thread;
         s_waylandConnection.thread = nullptr;
         s_waylandConnection.connection = nullptr;
     }
 }
 
 ConnectionThread *waylandConnection()
 {
     return s_waylandConnection.connection;
 }
 
 Compositor *waylandCompositor()
 {
     return s_waylandConnection.compositor;
 }
 
 SubCompositor *waylandSubCompositor()
 {
     return s_waylandConnection.subCompositor;
 }
 
 ShadowManager *waylandShadowManager()
 {
     return s_waylandConnection.shadowManager;
 }
 
 ShmPool *waylandShmPool()
 {
     return s_waylandConnection.shm;
 }
 
 Seat *waylandSeat()
 {
     return s_waylandConnection.seat;
 }
 
 ServerSideDecorationManager *waylandServerSideDecoration()
 {
     return s_waylandConnection.decoration;
 }
 
 PlasmaShell *waylandPlasmaShell()
 {
     return s_waylandConnection.plasmaShell;
 }
 
 PlasmaWindowManagement *waylandWindowManagement()
 {
     return s_waylandConnection.windowManagement;
 }
 
 PointerConstraints *waylandPointerConstraints()
 {
     return s_waylandConnection.pointerConstraints;
 }
 
 IdleInhibitManager *waylandIdleInhibitManager()
 {
     return s_waylandConnection.idleInhibit;
 }
 
 AppMenuManager* waylandAppMenuManager()
 {
     return s_waylandConnection.appMenu;
 }
 
 XdgDecorationManager *xdgDecorationManager()
 {
     return s_waylandConnection.xdgDecoration;
 }
 
 
 bool waitForWaylandPointer()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasPointerSpy(s_waylandConnection.seat, &Seat::hasPointerChanged);
     if (!hasPointerSpy.isValid()) {
         return false;
     }
     return hasPointerSpy.wait();
 }
 
 bool waitForWaylandTouch()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasTouchSpy(s_waylandConnection.seat, &Seat::hasTouchChanged);
     if (!hasTouchSpy.isValid()) {
         return false;
     }
     return hasTouchSpy.wait();
 }
 
 bool waitForWaylandKeyboard()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasKeyboardSpy(s_waylandConnection.seat, &Seat::hasKeyboardChanged);
     if (!hasKeyboardSpy.isValid()) {
         return false;
     }
     return hasKeyboardSpy.wait();
 }
 
 void render(Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format)
 {
     QImage img(size, format);
     img.fill(color);
     render(surface, img);
 }
 
 void render(Surface *surface, const QImage &img)
 {
     surface->attachBuffer(s_waylandConnection.shm->createBuffer(img));
     surface->damage(QRect(QPoint(0, 0), img.size()));
     surface->commit(Surface::CommitFlag::None);
 }
 
-XdgShellClient *waitForWaylandWindowShown(int timeout)
+AbstractClient *waitForWaylandWindowShown(int timeout)
 {
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     if (!clientAddedSpy.isValid()) {
         return nullptr;
     }
     if (!clientAddedSpy.wait(timeout)) {
         return nullptr;
     }
-    return clientAddedSpy.first().first().value<XdgShellClient *>();
+    return clientAddedSpy.first().first().value<AbstractClient *>();
 }
 
-XdgShellClient *renderAndWaitForShown(Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format, int timeout)
+AbstractClient *renderAndWaitForShown(Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format, int timeout)
 {
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     if (!clientAddedSpy.isValid()) {
         return nullptr;
     }
     render(surface, size, color, format);
     flushWaylandConnection();
     if (!clientAddedSpy.wait(timeout)) {
         return nullptr;
     }
-    return clientAddedSpy.first().first().value<XdgShellClient *>();
+    return clientAddedSpy.first().first().value<AbstractClient *>();
 }
 
 void flushWaylandConnection()
 {
     if (s_waylandConnection.connection) {
         s_waylandConnection.connection->flush();
     }
 }
 
 Surface *createSurface(QObject *parent)
 {
     if (!s_waylandConnection.compositor) {
         return nullptr;
     }
     auto s = s_waylandConnection.compositor->createSurface(parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 SubSurface *createSubSurface(Surface *surface, Surface *parentSurface, QObject *parent)
 {
     if (!s_waylandConnection.subCompositor) {
         return nullptr;
     }
     auto s = s_waylandConnection.subCompositor->createSubSurface(surface, parentSurface, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 XdgShellSurface *createXdgShellV6Surface(Surface *surface, QObject *parent, CreationSetup creationSetup)
 {
     if (!s_waylandConnection.xdgShellV6) {
         return nullptr;
     }
     auto s = s_waylandConnection.xdgShellV6->createSurface(surface, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     if (creationSetup == CreationSetup::CreateAndConfigure) {
         initXdgShellSurface(surface, s);
     }
     return s;
 }
 
 XdgShellSurface *createXdgShellStableSurface(Surface *surface, QObject *parent, CreationSetup creationSetup)
 {
     if (!s_waylandConnection.xdgShellStable) {
         return nullptr;
     }
     auto s = s_waylandConnection.xdgShellStable->createSurface(surface, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     if (creationSetup == CreationSetup::CreateAndConfigure) {
         initXdgShellSurface(surface, s);
     }
     return s;
 }
 
 XdgShellPopup *createXdgShellStablePopup(Surface *surface, XdgShellSurface *parentSurface, const XdgPositioner &positioner, QObject *parent, CreationSetup creationSetup)
 {
     if (!s_waylandConnection.xdgShellStable) {
         return nullptr;
     }
     auto s = s_waylandConnection.xdgShellStable->createPopup(surface, parentSurface, positioner, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     if (creationSetup == CreationSetup::CreateAndConfigure) {
         initXdgShellPopup(surface, s);
     }
     return s;
 }
 
 void initXdgShellSurface(KWayland::Client::Surface *surface, KWayland::Client::XdgShellSurface *shellSurface)
 {
     //wait for configure
     QSignalSpy configureRequestedSpy(shellSurface, &KWayland::Client::XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
 }
 
 void initXdgShellPopup(KWayland::Client::Surface *surface, KWayland::Client::XdgShellPopup *shellPopup)
 {
     //wait for configure
     QSignalSpy configureRequestedSpy(shellPopup, &KWayland::Client::XdgShellPopup::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     shellPopup->ackConfigure(configureRequestedSpy.last()[1].toInt());
 }
 
 KWayland::Client::XdgShellSurface *createXdgShellSurface(XdgShellSurfaceType type, KWayland::Client::Surface *surface, QObject *parent, CreationSetup creationSetup)
 {
     switch (type) {
     case XdgShellSurfaceType::XdgShellV6:
         return createXdgShellV6Surface(surface, parent, creationSetup);
     case XdgShellSurfaceType::XdgShellStable:
         return createXdgShellStableSurface(surface, parent, creationSetup);
     default:
         return nullptr;
     }
 }
 
 bool waitForWindowDestroyed(AbstractClient *client)
 {
     QSignalSpy destroyedSpy(client, &QObject::destroyed);
     if (!destroyedSpy.isValid()) {
         return false;
     }
     return destroyedSpy.wait();
 }
 
 bool lockScreen()
 {
     if (waylandServer()->isScreenLocked()) {
         return false;
     }
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     if (!lockStateChangedSpy.isValid()) {
         return false;
     }
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     if (lockStateChangedSpy.count() != 1) {
         return false;
     }
     if (!waylandServer()->isScreenLocked()) {
         return false;
     }
     if (!ScreenLockerWatcher::self()->isLocked()) {
         QSignalSpy lockedSpy(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked);
         if (!lockedSpy.isValid()) {
             return false;
         }
         if (!lockedSpy.wait()) {
             return false;
         }
         if (!ScreenLockerWatcher::self()->isLocked()) {
             return false;
         }
     }
     return true;
 }
 
 bool unlockScreen()
 {
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     if (!lockStateChangedSpy.isValid()) {
         return false;
     }
     using namespace ScreenLocker;
     const auto children = KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
     if (waylandServer()->isScreenLocked()) {
         lockStateChangedSpy.wait();
     }
     if (waylandServer()->isScreenLocked()) {
         return true;
     }
     if (ScreenLockerWatcher::self()->isLocked()) {
         QSignalSpy lockedSpy(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked);
         if (!lockedSpy.isValid()) {
             return false;
         }
         if (!lockedSpy.wait()) {
             return false;
         }
         if (ScreenLockerWatcher::self()->isLocked()) {
             return false;
         }
     }
     return true;
 }
 
 }
 }
diff --git a/autotests/integration/touch_input_test.cpp b/autotests/integration/touch_input_test.cpp
index 3e87fb9cf..f494b3fba 100644
--- a/autotests/integration/touch_input_test.cpp
+++ b/autotests/integration/touch_input_test.cpp
@@ -1,284 +1,283 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
 #include "cursor.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_touch_input-0");
 
 class TouchInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testTouchHidesCursor();
     void testMultipleTouchPoints_data();
     void testMultipleTouchPoints();
     void testCancel();
     void testTouchMouseAction();
 
 private:
     AbstractClient *showWindow(bool decorated = false);
     KWayland::Client::Touch *m_touch = nullptr;
 };
 
 void TouchInputTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TouchInputTest::init()
 {
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::Decoration));
     QVERIFY(Test::waitForWaylandTouch());
     m_touch = Test::waylandSeat()->createTouch(Test::waylandSeat());
     QVERIFY(m_touch);
     QVERIFY(m_touch->isValid());
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(1280, 512));
 }
 
 void TouchInputTest::cleanup()
 {
     delete m_touch;
     m_touch = nullptr;
     Test::destroyWaylandConnection();
 }
 
 AbstractClient *TouchInputTest::showWindow(bool decorated)
 {
     using namespace KWayland::Client;
 #define VERIFY(statement) \
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
         return nullptr;
 #define COMPARE(actual, expected) \
     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\
         return nullptr;
 
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     VERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     VERIFY(shellSurface);
     if (decorated) {
         auto deco = Test::waylandServerSideDecoration()->create(surface, surface);
         QSignalSpy decoSpy(deco, &ServerSideDecoration::modeChanged);
         VERIFY(decoSpy.isValid());
         VERIFY(decoSpy.wait());
         deco->requestMode(ServerSideDecoration::Mode::Server);
         VERIFY(decoSpy.wait());
         COMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
     }
     // let's render
     auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
 
     VERIFY(c);
     COMPARE(workspace()->activeClient(), c);
 
 #undef VERIFY
 #undef COMPARE
 
     return c;
 }
 
 void TouchInputTest::testTouchHidesCursor()
 {
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->touchDown(2, QPointF(130, 125), timestamp++);
     kwinApp()->platform()->touchUp(2, timestamp++);
     kwinApp()->platform()->touchUp(1, timestamp++);
 
     // now a mouse event should show the cursor again
     kwinApp()->platform()->pointerMotion(QPointF(0, 0), timestamp++);
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 
     // touch should hide again
     kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
 
     // wheel should also show
     kwinApp()->platform()->pointerAxisVertical(1.0, timestamp++);
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 }
 
 void TouchInputTest::testMultipleTouchPoints_data()
 {
     QTest::addColumn<bool>("decorated");
 
     QTest::newRow("undecorated") << false;
     QTest::newRow("decorated") << true;
 }
 
 void TouchInputTest::testMultipleTouchPoints()
 {
     using namespace KWayland::Client;
     QFETCH(bool, decorated);
     AbstractClient *c = showWindow(decorated);
     QCOMPARE(c->isDecorated(), decorated);
     c->move(100, 100);
     QVERIFY(c);
     QSignalSpy sequenceStartedSpy(m_touch, &Touch::sequenceStarted);
     QVERIFY(sequenceStartedSpy.isValid());
     QSignalSpy pointAddedSpy(m_touch, &Touch::pointAdded);
     QVERIFY(pointAddedSpy.isValid());
     QSignalSpy pointMovedSpy(m_touch, &Touch::pointMoved);
     QVERIFY(pointMovedSpy.isValid());
     QSignalSpy pointRemovedSpy(m_touch, &Touch::pointRemoved);
     QVERIFY(pointRemovedSpy.isValid());
     QSignalSpy endedSpy(m_touch, &Touch::sequenceEnded);
     QVERIFY(endedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, QPointF(125, 125) + c->clientPos(), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 1);
     QCOMPARE(m_touch->sequence().count(), 1);
     QCOMPARE(m_touch->sequence().first()->isDown(), true);
     QCOMPARE(m_touch->sequence().first()->position(), QPointF(25, 25));
     QCOMPARE(pointAddedSpy.count(), 0);
     QCOMPARE(pointMovedSpy.count(), 0);
 
     // a point outside the window
     kwinApp()->platform()->touchDown(2, QPointF(0, 0) + c->clientPos(), timestamp++);
     QVERIFY(pointAddedSpy.wait());
     QCOMPARE(pointAddedSpy.count(), 1);
     QCOMPARE(m_touch->sequence().count(), 2);
     QCOMPARE(m_touch->sequence().at(1)->isDown(), true);
     QCOMPARE(m_touch->sequence().at(1)->position(), QPointF(-100, -100));
     QCOMPARE(pointMovedSpy.count(), 0);
 
     // let's move that one
     kwinApp()->platform()->touchMotion(2, QPointF(100, 100) + c->clientPos(), timestamp++);
     QVERIFY(pointMovedSpy.wait());
     QCOMPARE(pointMovedSpy.count(), 1);
     QCOMPARE(m_touch->sequence().count(), 2);
     QCOMPARE(m_touch->sequence().at(1)->isDown(), true);
     QCOMPARE(m_touch->sequence().at(1)->position(), QPointF(0, 0));
 
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(pointRemovedSpy.wait());
     QCOMPARE(pointRemovedSpy.count(), 1);
     QCOMPARE(m_touch->sequence().count(), 2);
     QCOMPARE(m_touch->sequence().first()->isDown(), false);
     QCOMPARE(endedSpy.count(), 0);
 
     kwinApp()->platform()->touchUp(2, timestamp++);
     QVERIFY(pointRemovedSpy.wait());
     QCOMPARE(pointRemovedSpy.count(), 2);
     QCOMPARE(m_touch->sequence().count(), 2);
     QCOMPARE(m_touch->sequence().first()->isDown(), false);
     QCOMPARE(m_touch->sequence().at(1)->isDown(), false);
     QCOMPARE(endedSpy.count(), 1);
 }
 
 void TouchInputTest::testCancel()
 {
     using namespace KWayland::Client;
     AbstractClient *c = showWindow();
     c->move(100, 100);
     QVERIFY(c);
     QSignalSpy sequenceStartedSpy(m_touch, &Touch::sequenceStarted);
     QVERIFY(sequenceStartedSpy.isValid());
     QSignalSpy cancelSpy(m_touch, &Touch::sequenceCanceled);
     QVERIFY(cancelSpy.isValid());
     QSignalSpy pointRemovedSpy(m_touch, &Touch::pointRemoved);
     QVERIFY(pointRemovedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, QPointF(125, 125), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 1);
 
     // cancel
     kwinApp()->platform()->touchCancel();
     QVERIFY(cancelSpy.wait());
     QCOMPARE(cancelSpy.count(), 1);
 
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(!pointRemovedSpy.wait(100));
     QCOMPARE(pointRemovedSpy.count(), 0);
 }
 
 void TouchInputTest::testTouchMouseAction()
 {
     // this test verifies that a touch down on an inactive client will activate it
     using namespace KWayland::Client;
     // create two windows
     AbstractClient *c1 = showWindow();
     QVERIFY(c1);
     AbstractClient *c2 = showWindow();
     QVERIFY(c2);
 
     QVERIFY(!c1->isActive());
     QVERIFY(c2->isActive());
 
     // also create a sequence started spy as the touch event should be passed through
     QSignalSpy sequenceStartedSpy(m_touch, &Touch::sequenceStarted);
     QVERIFY(sequenceStartedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, c1->frameGeometry().center(), timestamp++);
     QVERIFY(c1->isActive());
 
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 1);
 
     // cleanup
     kwinApp()->platform()->touchCancel();
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::TouchInputTest)
 #include "touch_input_test.moc"
diff --git a/autotests/integration/transient_placement.cpp b/autotests/integration/transient_placement.cpp
index 368395714..49578bec2 100644
--- a/autotests/integration/transient_placement.cpp
+++ b/autotests/integration/transient_placement.cpp
@@ -1,368 +1,366 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_transient_placement-0");
 
 class TransientPlacementTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testXdgPopup_data();
     void testXdgPopup();
     void testXdgPopupWithPanel();
 };
 
 void TransientPlacementTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void TransientPlacementTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration | Test::AdditionalWaylandInterface::PlasmaShell));
 
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
 }
 
 void TransientPlacementTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TransientPlacementTest::testXdgPopup_data()
 {
     using namespace KWayland::Client;
 
     QTest::addColumn<QSize>("parentSize");
     QTest::addColumn<QPoint>("parentPosition");
     QTest::addColumn<XdgPositioner>("positioner");
     QTest::addColumn<QRect>("expectedGeometry");
 
     // window in the middle, plenty of room either side: Changing anchor
 
     // parent window is 500,500, starting at 300,300, anchorRect is therefore between 350->750 in both dirs
     XdgPositioner positioner(QSize(200,200), QRect(50,50, 400,400));
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
 
     positioner.setAnchorEdge(Qt::Edges());
     QTest::newRow("anchorCentre") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 550, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge | Qt::LeftEdge);
     QTest::newRow("anchorTopLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350,350, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge);
     QTest::newRow("anchorTop") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 350, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge | Qt::RightEdge);
     QTest::newRow("anchorTopRight") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(750, 350, 200, 200);
     positioner.setAnchorEdge(Qt::RightEdge);
     QTest::newRow("anchorRight") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(750, 550, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     QTest::newRow("anchorBottomRight") << QSize(500,500) << QPoint(300,300) << positioner << QRect(750, 750, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge);
     QTest::newRow("anchorBottom") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 750, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::LeftEdge);
     QTest::newRow("anchorBottomLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350, 750, 200, 200);
     positioner.setAnchorEdge(Qt::LeftEdge);
     QTest::newRow("anchorLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350, 550, 200, 200);
 
     // ----------------------------------------------------------------
     // window in the middle, plenty of room either side: Changing gravity around the bottom right anchor
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::Edges());
     QTest::newRow("gravityCentre") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 650, 200, 200);
     positioner.setGravity(Qt::TopEdge | Qt::LeftEdge);
     QTest::newRow("gravityTopLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 550, 200, 200);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("gravityTop") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 550, 200, 200);
     positioner.setGravity(Qt::TopEdge | Qt::RightEdge);
     QTest::newRow("gravityTopRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 550, 200, 200);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("gravityRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 650, 200, 200);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QTest::newRow("gravityBottomRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 750, 200, 200);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("gravityBottom") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 750, 200, 200);
     positioner.setGravity(Qt::BottomEdge | Qt::LeftEdge);
     QTest::newRow("gravityBottomLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 750, 200, 200);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("gravityLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 650, 200, 200);
 
     // ----------------------------------------------------------------
     //constrain and slide
     //popup is still 200,200. window moved near edge of screen, popup always comes out towards the screen edge
     positioner.setConstraints(XdgPositioner::Constraint::SlideX | XdgPositioner::Constraint::SlideY);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("constraintSlideTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 250 - 100, 0, 200, 200);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("constraintSlideLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(0, 80 + 250 - 100, 200, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("constraintSlideRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(1280 - 200, 80 + 250 - 100, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("constraintSlideBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(80 + 250 - 100, 1024 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge| Qt::RightEdge);
     QTest::newRow("constraintSlideBottomRight") << QSize(500, 500) << QPoint(700, 1000) << positioner << QRect(1280 - 200, 1024 - 200, 200, 200);
 
 
     // ----------------------------------------------------------------
     // constrain and flip
     positioner.setConstraints(XdgPositioner::Constraint::FlipX | XdgPositioner::Constraint::FlipY);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("constraintFlipTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(230, 80 + 500 - 50, 200, 200);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("constraintFlipLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 500 - 50, 230, 200, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("constraintFlipRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 - 200, 230, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("constraintFlipBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(230, 500 + 50 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge| Qt::RightEdge);
     QTest::newRow("constraintFlipBottomRight") << QSize(500, 500) << QPoint(700, 500) << positioner << QRect(700 + 50 - 200, 500 + 50 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::RightEdge);
     //as popup is positioned in the middle of the parent we need a massive popup to be able to overflow
     positioner.setInitialSize(QSize(400, 400));
     QTest::newRow("constraintFlipRightNoAnchor") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 250 - 400, 330, 400, 400);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::TopEdge);
     positioner.setInitialSize(QSize(300, 200));
     QTest::newRow("constraintFlipRightNoGravity") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 - 150, 130, 300, 200);
 
     // ----------------------------------------------------------------
     // resize
     positioner.setConstraints(XdgPositioner::Constraint::ResizeX | XdgPositioner::Constraint::ResizeY);
     positioner.setInitialSize(QSize(200, 200));
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("resizeTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 250 - 100, 0, 200, 130);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("resizeLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(0, 80 + 250 - 100, 130, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("resizeRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 + 400, 80 + 250 - 100, 130, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("resizeBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(80 + 250 - 100, 500 + 50 + 400, 200, 74);
 }
 
 void TransientPlacementTest::testXdgPopup()
 {
     using namespace KWayland::Client;
 
     // this test verifies that the position of a transient window is taken from the passed position
     // there are no further constraints like window too large to fit screen, cascading transients, etc
     // some test cases also verify that the transient fits on the screen
     QFETCH(QSize, parentSize);
     QFETCH(QPoint, parentPosition);
     QFETCH(QRect, expectedGeometry);
     const QRect expectedRelativeGeometry = expectedGeometry.translated(-parentPosition);
 
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto parentShellSurface = Test::createXdgShellStableSurface(surface, Test::waylandCompositor());
     QVERIFY(parentShellSurface);
     auto parent = Test::renderAndWaitForShown(surface, parentSize, Qt::blue);
     QVERIFY(parent);
 
     QVERIFY(!parent->isDecorated());
     parent->move(parentPosition);
     QCOMPARE(parent->frameGeometry(), QRect(parentPosition, parentSize));
 
     //create popup
     QFETCH(XdgPositioner, positioner);
 
     Surface *transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
 
     auto popup = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner, Test::waylandCompositor(), Test::CreationSetup::CreateOnly);
     QSignalSpy configureRequestedSpy(popup, &XdgShellPopup::configureRequested);
     transientSurface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first()[0].value<QRect>(), expectedRelativeGeometry);
     popup->ackConfigure(configureRequestedSpy.first()[1].toUInt());
 
     auto transient = Test::renderAndWaitForShown(transientSurface, expectedRelativeGeometry.size(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
     QCOMPARE(transient->frameGeometry(), expectedGeometry);
 
     QCOMPARE(configureRequestedSpy.count(), 1); // check that we did not get reconfigured
 }
 
 void TransientPlacementTest::testXdgPopupWithPanel()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface{Test::createSurface()};
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> dockShellSurface{Test::createXdgShellStableSurface(surface.data(), surface.data())};
     QVERIFY(!dockShellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPosition(QPoint(0, screens()->geometry(0).height() - 50));
     plasmaSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AlwaysVisible);
 
     // now render and map the window
     QVERIFY(workspace()->clientArea(PlacementArea, 0, 1) == workspace()->clientArea(FullScreenArea, 0, 1));
     auto dock = Test::renderAndWaitForShown(surface.data(), QSize(1280, 50), Qt::blue);
     QVERIFY(dock);
     QCOMPARE(dock->windowType(), NET::Dock);
     QVERIFY(dock->isDock());
     QCOMPARE(dock->frameGeometry(), QRect(0, screens()->geometry(0).height() - 50, 1280, 50));
     QCOMPARE(dock->hasStrut(), true);
     QVERIFY(workspace()->clientArea(PlacementArea, 0, 1) != workspace()->clientArea(FullScreenArea, 0, 1));
 
     //create parent
     Surface *parentSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(parentSurface);
     auto parentShellSurface = Test::createXdgShellStableSurface(parentSurface, Test::waylandCompositor());
     QVERIFY(parentShellSurface);
     auto parent = Test::renderAndWaitForShown(parentSurface, {800, 600}, Qt::blue);
     QVERIFY(parent);
 
     QVERIFY(!parent->isDecorated());
     parent->move({0, screens()->geometry(0).height() - 600});
     parent->keepInArea(workspace()->clientArea(PlacementArea, parent));
     QCOMPARE(parent->frameGeometry(), QRect(0, screens()->geometry(0).height() - 600 - 50, 800, 600));
 
     Surface *transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
     XdgPositioner positioner(QSize(200,200), QRect(50,500, 200,200));
 
     auto transientShellSurface = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner, Test::waylandCompositor());
     auto transient = Test::renderAndWaitForShown(transientSurface, positioner.initialSize(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
 
     QCOMPARE(transient->frameGeometry(), QRect(50, screens()->geometry(0).height() - 200 - 50, 200, 200));
 
     transientShellSurface->deleteLater();
     transientSurface->deleteLater();
     QVERIFY(Test::waitForWindowDestroyed(transient));
 
     // now parent to fullscreen - on fullscreen the panel is ignored
     QSignalSpy fullscreenSpy{parentShellSurface, &XdgShellSurface::configureRequested};
     QVERIFY(fullscreenSpy.isValid());
     parent->setFullScreen(true);
     QVERIFY(fullscreenSpy.wait());
     parentShellSurface->ackConfigure(fullscreenSpy.first().at(2).value<quint32>());
-    QSignalSpy frameGeometryChangedSpy{parent, &XdgShellClient::frameGeometryChanged};
+    QSignalSpy frameGeometryChangedSpy{parent, &AbstractClient::frameGeometryChanged};
     QVERIFY(frameGeometryChangedSpy.isValid());
     Test::render(parentSurface, fullscreenSpy.first().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(parent->frameGeometry(), screens()->geometry(0));
     QVERIFY(parent->isFullScreen());
 
     // another transient, with same hints as before from bottom of window
     transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
 
     XdgPositioner positioner2(QSize(200,200), QRect(50,screens()->geometry(0).height()-100, 200,200));
     transientShellSurface = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner2, Test::waylandCompositor());
     transient = Test::renderAndWaitForShown(transientSurface, positioner2.initialSize(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
 
     QCOMPARE(transient->frameGeometry(), QRect(50, screens()->geometry(0).height() - 200, 200, 200));
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::TransientPlacementTest)
 #include "transient_placement.moc"
diff --git a/autotests/integration/virtual_desktop_test.cpp b/autotests/integration/virtual_desktop_test.cpp
index dcaa89e8b..42d7a67b2 100644
--- a/autotests/integration/virtual_desktop_test.cpp
+++ b/autotests/integration/virtual_desktop_test.cpp
@@ -1,329 +1,328 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "main.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "virtualdesktops.h"
 
 #include <KWayland/Client/surface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_virtualdesktop-0");
 
 class VirtualDesktopTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testNetCurrentDesktop();
     void testLastDesktopRemoved_data();
     void testLastDesktopRemoved();
     void testWindowOnMultipleDesktops_data();
     void testWindowOnMultipleDesktops();
     void testRemoveDesktopWithWindow_data();
     void testRemoveDesktopWithWindow();
 };
 
 void VirtualDesktopTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 
     if (kwinApp()->x11Connection()) {
         // verify the current desktop x11 property on startup, see BUG: 391034
         Xcb::Atom currentDesktopAtom("_NET_CURRENT_DESKTOP");
         QVERIFY(currentDesktopAtom.isValid());
         Xcb::Property currentDesktop(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
         bool ok = true;
         QCOMPARE(currentDesktop.value(0, &ok), 0);
         QVERIFY(ok);
     }
 }
 
 void VirtualDesktopTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     VirtualDesktopManager::self()->setCount(1);
 }
 
 void VirtualDesktopTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void VirtualDesktopTest::testNetCurrentDesktop()
 {
     if (!kwinApp()->x11Connection()) {
         QSKIP("Skipped on Wayland only");
     }
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
     VirtualDesktopManager::self()->setCount(4);
     QCOMPARE(VirtualDesktopManager::self()->count(), 4u);
 
     Xcb::Atom currentDesktopAtom("_NET_CURRENT_DESKTOP");
     QVERIFY(currentDesktopAtom.isValid());
     Xcb::Property currentDesktop(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
     bool ok = true;
     QCOMPARE(currentDesktop.value(0, &ok), 0);
     QVERIFY(ok);
 
     // go to desktop 2
     VirtualDesktopManager::self()->setCurrent(2);
     currentDesktop = Xcb::Property(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
     QCOMPARE(currentDesktop.value(0, &ok), 1);
     QVERIFY(ok);
 
     // go to desktop 3
     VirtualDesktopManager::self()->setCurrent(3);
     currentDesktop = Xcb::Property(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
     QCOMPARE(currentDesktop.value(0, &ok), 2);
     QVERIFY(ok);
 
     // go to desktop 4
     VirtualDesktopManager::self()->setCurrent(4);
     currentDesktop = Xcb::Property(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
     QCOMPARE(currentDesktop.value(0, &ok), 3);
     QVERIFY(ok);
 
     // and back to first
     VirtualDesktopManager::self()->setCurrent(1);
     currentDesktop = Xcb::Property(0, kwinApp()->x11RootWindow(), currentDesktopAtom, XCB_ATOM_CARDINAL, 0, 1);
     QCOMPARE(currentDesktop.value(0, &ok), 0);
     QVERIFY(ok);
 }
 
 void VirtualDesktopTest::testLastDesktopRemoved_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void VirtualDesktopTest::testLastDesktopRemoved()
 {
     // first create a new desktop
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // switch to last desktop
     VirtualDesktopManager::self()->setCurrent(VirtualDesktopManager::self()->desktops().last());
     QCOMPARE(VirtualDesktopManager::self()->current(), 2u);
 
     // now create a window on this desktop
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(client);
     QCOMPARE(client->desktop(), 2);
-    QSignalSpy desktopPresenceChangedSpy(client, &XdgShellClient::desktopPresenceChanged);
+    QSignalSpy desktopPresenceChangedSpy(client, &AbstractClient::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedSpy.isValid());
 
     QCOMPARE(client->desktops().count(), 1u);
     QCOMPARE(VirtualDesktopManager::self()->currentDesktop(), client->desktops().first());
 
     // and remove last desktop
     VirtualDesktopManager::self()->setCount(1);
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
     // now the client should be moved as well
     QTRY_COMPARE(desktopPresenceChangedSpy.count(), 1);
     QCOMPARE(client->desktop(), 1);
 
     QCOMPARE(client->desktops().count(), 1u);
     QCOMPARE(VirtualDesktopManager::self()->currentDesktop(), client->desktops().first());
 }
 
 void VirtualDesktopTest::testWindowOnMultipleDesktops_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void VirtualDesktopTest::testWindowOnMultipleDesktops()
 {
     // first create two new desktops
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
     VirtualDesktopManager::self()->setCount(3);
     QCOMPARE(VirtualDesktopManager::self()->count(), 3u);
 
     // switch to last desktop
     VirtualDesktopManager::self()->setCurrent(VirtualDesktopManager::self()->desktops().last());
     QCOMPARE(VirtualDesktopManager::self()->current(), 3u);
 
     // now create a window on this desktop
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(client);
     QCOMPARE(client->desktop(), 3u);
-    QSignalSpy desktopPresenceChangedSpy(client, &XdgShellClient::desktopPresenceChanged);
+    QSignalSpy desktopPresenceChangedSpy(client, &AbstractClient::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedSpy.isValid());
 
     QCOMPARE(client->desktops().count(), 1u);
     QCOMPARE(VirtualDesktopManager::self()->currentDesktop(), client->desktops().first());
 
     //Set the window on desktop 2 as well
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(2));
     QCOMPARE(client->desktops().count(), 2u);
     QCOMPARE(VirtualDesktopManager::self()->desktops()[2], client->desktops()[0]);
     QCOMPARE(VirtualDesktopManager::self()->desktops()[1], client->desktops()[1]);
     QVERIFY(client->isOnDesktop(2));
     QVERIFY(client->isOnDesktop(3));
 
     //leave desktop 3
     client->leaveDesktop(VirtualDesktopManager::self()->desktopForX11Id(3));
     QCOMPARE(client->desktops().count(), 1u);
     //leave desktop 2
     client->leaveDesktop(VirtualDesktopManager::self()->desktopForX11Id(2));
     QCOMPARE(client->desktops().count(), 0u);
     //we should be on all desktops now
     QVERIFY(client->isOnAllDesktops());
     //put on desktop 1
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(1));
     QVERIFY(client->isOnDesktop(1));
     QVERIFY(!client->isOnDesktop(2));
     QVERIFY(!client->isOnDesktop(3));
     QCOMPARE(client->desktops().count(), 1u);
     //put on desktop 2
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(2));
     QVERIFY(client->isOnDesktop(1));
     QVERIFY(client->isOnDesktop(2));
     QVERIFY(!client->isOnDesktop(3));
     QCOMPARE(client->desktops().count(), 2u);
     //put on desktop 3
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(3));
     QVERIFY(client->isOnDesktop(1));
     QVERIFY(client->isOnDesktop(2));
     QVERIFY(client->isOnDesktop(3));
     QCOMPARE(client->desktops().count(), 3u);
 
     //entering twice dooes nothing
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(3));
     QCOMPARE(client->desktops().count(), 3u);
 
     //adding to "all desktops" results in just that one desktop
     client->setOnAllDesktops(true);
     QCOMPARE(client->desktops().count(), 0u);
     client->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(3));
     QVERIFY(client->isOnDesktop(3));
     QCOMPARE(client->desktops().count(), 1u);
 
     //leaving a desktop on "all desktops" puts on everything else
     client->setOnAllDesktops(true);
     QCOMPARE(client->desktops().count(), 0u);
     client->leaveDesktop(VirtualDesktopManager::self()->desktopForX11Id(3));
     QVERIFY(client->isOnDesktop(1));
     QVERIFY(client->isOnDesktop(2));
     QCOMPARE(client->desktops().count(), 2u);
 }
 
 void VirtualDesktopTest::testRemoveDesktopWithWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void VirtualDesktopTest::testRemoveDesktopWithWindow()
 {
     // first create two new desktops
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
     VirtualDesktopManager::self()->setCount(3);
     QCOMPARE(VirtualDesktopManager::self()->count(), 3u);
 
     // switch to last desktop
     VirtualDesktopManager::self()->setCurrent(VirtualDesktopManager::self()->desktops().last());
     QCOMPARE(VirtualDesktopManager::self()->current(), 3u);
 
     // now create a window on this desktop
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(client);
     QCOMPARE(client->desktop(), 3u);
-    QSignalSpy desktopPresenceChangedSpy(client, &XdgShellClient::desktopPresenceChanged);
+    QSignalSpy desktopPresenceChangedSpy(client, &AbstractClient::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedSpy.isValid());
 
     QCOMPARE(client->desktops().count(), 1u);
     QCOMPARE(VirtualDesktopManager::self()->currentDesktop(), client->desktops().first());
 
     //Set the window on desktop 2 as well
     client->enterDesktop(VirtualDesktopManager::self()->desktops()[1]);
     QCOMPARE(client->desktops().count(), 2u);
     QCOMPARE(VirtualDesktopManager::self()->desktops()[2], client->desktops()[0]);
     QCOMPARE(VirtualDesktopManager::self()->desktops()[1], client->desktops()[1]);
     QVERIFY(client->isOnDesktop(2));
     QVERIFY(client->isOnDesktop(3));
 
     //remove desktop 3
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(client->desktops().count(), 1u);
     //window is only on desktop 2
     QCOMPARE(VirtualDesktopManager::self()->desktops()[1], client->desktops()[0]);
 
     //Again 3 desktops
     VirtualDesktopManager::self()->setCount(3);
     //move window to be only on desktop 3
     client->enterDesktop(VirtualDesktopManager::self()->desktops()[2]);
     client->leaveDesktop(VirtualDesktopManager::self()->desktops()[1]);
     QCOMPARE(client->desktops().count(), 1u);
     //window is only on desktop 3
     QCOMPARE(VirtualDesktopManager::self()->desktops()[2], client->desktops()[0]);
 
     //remove desktop 3
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(client->desktops().count(), 1u);
     //window is only on desktop 2
     QCOMPARE(VirtualDesktopManager::self()->desktops()[1], client->desktops()[0]);
 }
 
 WAYLANDTEST_MAIN(VirtualDesktopTest)
 #include "virtual_desktop_test.moc"
diff --git a/autotests/integration/window_rules_test.cpp b/autotests/integration/window_rules_test.cpp
index 6302b9740..ec9720d09 100644
--- a/autotests/integration/window_rules_test.cpp
+++ b/autotests/integration/window_rules_test.cpp
@@ -1,251 +1,249 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "atoms.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "rules.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_window_rules-0");
 
 class WindowRuleTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testApplyInitialMaximizeVert_data();
     void testApplyInitialMaximizeVert();
     void testWindowClassChange();
 };
 
 void WindowRuleTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void WindowRuleTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
     QVERIFY(waylandServer()->clients().isEmpty());
 }
 
 void WindowRuleTest::cleanup()
 {
     // discards old rules
     RuleBook::self()->load();
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void WindowRuleTest::testApplyInitialMaximizeVert_data()
 {
     QTest::addColumn<QByteArray>("role");
 
     QTest::newRow("lowercase") << QByteArrayLiteral("mainwindow");
     QTest::newRow("CamelCase") << QByteArrayLiteral("MainWindow");
 }
 
 void WindowRuleTest::testApplyInitialMaximizeVert()
 {
     // this test creates the situation of BUG 367554: creates a window and initial apply maximize vertical
     // the window is matched by class and role
     // load the rule
     QFile ruleFile(QFINDTESTDATA("./data/rules/maximize-vert-apply-initial"));
     QVERIFY(ruleFile.open(QIODevice::ReadOnly | QIODevice::Text));
     QMetaObject::invokeMethod(RuleBook::self(), "temporaryRulesMessage", Q_ARG(QString, QString::fromUtf8(ruleFile.readAll())));
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 10, 20);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_icccm_set_wm_class(c.data(), w, 9, "kpat\0kpat");
 
     QFETCH(QByteArray, role);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atoms->wm_window_role, XCB_ATOM_STRING, 8, role.length(), role.constData());
 
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
     QVERIFY(!client->readyForPainting());
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
     QCOMPARE(client->maximizeMode(), MaximizeVertical);
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void WindowRuleTest::testWindowClassChange()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
 
     auto group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", 2);
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", 1);
     group.sync();
 
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 10, 20);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_icccm_set_wm_class(c.data(), w, 23, "org.kde.bar\0org.kde.bar");
 
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
     QVERIFY(!client->readyForPainting());
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
     QCOMPARE(client->keepAbove(), false);
 
     // now change class
     QSignalSpy windowClassChangedSpy{client, &X11Client::windowClassChanged};
     QVERIFY(windowClassChangedSpy.isValid());
     xcb_icccm_set_wm_class(c.data(), w, 23, "org.kde.foo\0org.kde.foo");
     xcb_flush(c.data());
     QVERIFY(windowClassChangedSpy.wait());
     QCOMPARE(client->keepAbove(), true);
 
     // destroy window
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::WindowRuleTest)
 #include "window_rules_test.moc"
diff --git a/autotests/integration/window_selection_test.cpp b/autotests/integration/window_selection_test.cpp
index a0d0fffda..9429b5dc2 100644
--- a/autotests/integration/window_selection_test.cpp
+++ b/autotests/integration/window_selection_test.cpp
@@ -1,558 +1,557 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "keyboard_input.h"
 #include "platform.h"
 #include "pointer_input.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_window_selection-0");
 
 class TestWindowSelection : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testSelectOnWindowPointer();
     void testSelectOnWindowKeyboard_data();
     void testSelectOnWindowKeyboard();
     void testSelectOnWindowTouch();
     void testCancelOnWindowPointer();
     void testCancelOnWindowKeyboard();
 
     void testSelectPointPointer();
     void testSelectPointTouch();
 };
 
 void TestWindowSelection::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestWindowSelection::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestWindowSelection::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestWindowSelection::testSelectOnWindowPointer()
 {
     // this test verifies window selection through pointer works
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(input()->pointer()->focus().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QVERIFY(input()->pointer()->focus().isNull());
 
     // updating the pointer should not change anything
     input()->pointer()->update();
     QVERIFY(input()->pointer()->focus().isNull());
     // updating keyboard should also not change
     input()->keyboard()->update();
 
     // perform a right button click
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     // now release
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->pointer()->focus().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
 }
 
 void TestWindowSelection::testSelectOnWindowKeyboard_data()
 {
     QTest::addColumn<qint32>("key");
 
     QTest::newRow("enter") << KEY_ENTER;
     QTest::newRow("keypad enter") << KEY_KPENTER;
     QTest::newRow("space") << KEY_SPACE;
 }
 
 void TestWindowSelection::testSelectOnWindowKeyboard()
 {
     // this test verifies window selection through keyboard key
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     QVERIFY(!client->frameGeometry().contains(KWin::Cursor::pos()));
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(keyboardLeftSpy.wait());
     QCOMPARE(pointerLeftSpy.count(), 0);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate key press
     quint32 timestamp = 0;
     // move cursor through keys
     auto keyPress = [&timestamp] (qint32 key) {
         kwinApp()->platform()->keyboardKeyPressed(key, timestamp++);
         kwinApp()->platform()->keyboardKeyReleased(key, timestamp++);
     };
     while (KWin::Cursor::pos().x() >= client->frameGeometry().x() + client->frameGeometry().width()) {
         keyPress(KEY_LEFT);
     }
     while (KWin::Cursor::pos().x() <= client->frameGeometry().x()) {
         keyPress(KEY_RIGHT);
     }
     while (KWin::Cursor::pos().y() <= client->frameGeometry().y()) {
         keyPress(KEY_DOWN);
     }
     while (KWin::Cursor::pos().y() >= client->frameGeometry().y() + client->frameGeometry().height()) {
         keyPress(KEY_UP);
     }
     QFETCH(qint32, key);
     kwinApp()->platform()->keyboardKeyPressed(key, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->pointer()->focus().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 0);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 1);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyReleased(key, timestamp++);
 }
 
 void TestWindowSelection::testSelectOnWindowTouch()
 {
     // this test verifies window selection through touch
     QScopedPointer<Touch> touch(Test::waylandSeat()->createTouch());
     QSignalSpy touchStartedSpy(touch.data(), &Touch::sequenceStarted);
     QVERIFY(touchStartedSpy.isValid());
     QSignalSpy touchCanceledSpy(touch.data(), &Touch::sequenceCanceled);
     QVERIFY(touchCanceledSpy.isValid());
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
 
     // simulate touch down
     quint32 timestamp = 0;
     kwinApp()->platform()->touchDown(0, client->frameGeometry().center(), timestamp++);
     QVERIFY(!selectedWindow);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(selectedWindow, client);
 
     // with movement
     selectedWindow = nullptr;
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     kwinApp()->platform()->touchDown(0, client->frameGeometry().bottomRight() + QPoint(20, 20), timestamp++);
     QVERIFY(!selectedWindow);
     kwinApp()->platform()->touchMotion(0, client->frameGeometry().bottomRight() - QPoint(1, 1), timestamp++);
     QVERIFY(!selectedWindow);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->isSelectingWindow(), false);
 
     // it cancels active touch sequence on the window
     kwinApp()->platform()->touchDown(0, client->frameGeometry().center(), timestamp++);
     QVERIFY(touchStartedSpy.wait());
     selectedWindow = nullptr;
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(touchCanceledSpy.wait());
     QVERIFY(!selectedWindow);
     // this touch up does not yet select the window, it was started prior to the selection
     kwinApp()->platform()->touchUp(0, timestamp++);
     QVERIFY(!selectedWindow);
     kwinApp()->platform()->touchDown(0, client->frameGeometry().center(), timestamp++);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(selectedWindow, client);
     QCOMPARE(input()->isSelectingWindow(), false);
 
     QCOMPARE(touchStartedSpy.count(), 1);
     QCOMPARE(touchCanceledSpy.count(), 1);
 }
 
 void TestWindowSelection::testCancelOnWindowPointer()
 {
     // this test verifies that window selection cancels through right button click
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(input()->pointer()->focus().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QVERIFY(!selectedWindow);
     QCOMPARE(input()->pointer()->focus().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
 }
 
 void TestWindowSelection::testCancelOnWindowKeyboard()
 {
     // this test verifies that cancel window selection through escape key works
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(input()->pointer()->focus().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     Toplevel *selectedWindow = nullptr;
     auto callback = [&selectedWindow] (Toplevel *t) {
         selectedWindow = t;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractiveWindowSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QVERIFY(!selectedWindow);
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QVERIFY(!selectedWindow);
     QCOMPARE(input()->pointer()->focus().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, timestamp++);
 }
 
 void TestWindowSelection::testSelectPointPointer()
 {
     // this test verifies point selection through pointer works
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QSignalSpy pointerEnteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
     QSignalSpy pointerLeftSpy(pointer.data(), &Pointer::left);
     QVERIFY(pointerLeftSpy.isValid());
     QSignalSpy keyboardEnteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(keyboardEnteredSpy.isValid());
     QSignalSpy keyboardLeftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(keyboardLeftSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(keyboardEnteredSpy.wait());
     KWin::Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(input()->pointer()->focus().data(), client);
     QVERIFY(pointerEnteredSpy.wait());
 
     QPoint point;
     auto callback = [&point] (const QPoint &p) {
         point = p;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractivePositionSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QCOMPARE(point, QPoint());
     QCOMPARE(keyboardLeftSpy.count(), 0);
     QVERIFY(pointerLeftSpy.wait());
     if (keyboardLeftSpy.isEmpty()) {
         QVERIFY(keyboardLeftSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
 
     // trying again should not be allowed
     QPoint point2;
     kwinApp()->platform()->startInteractivePositionSelection([&point2] (const QPoint &p) {
         point2 = p;
     });
     QCOMPARE(point2, QPoint(-1, -1));
 
     // simulate left button press
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QCOMPARE(point, QPoint());
     QVERIFY(input()->pointer()->focus().isNull());
 
     // updating the pointer should not change anything
     input()->pointer()->update();
     QVERIFY(input()->pointer()->focus().isNull());
     // updating keyboard should also not change
     input()->keyboard()->update();
 
     // perform a right button click
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     // should not have ended the mode
     QCOMPARE(input()->isSelectingWindow(), true);
     QCOMPARE(point, QPoint());
     // now release
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(point, input()->globalPointer().toPoint());
     QCOMPARE(input()->pointer()->focus().data(), client);
     // should give back keyboard and pointer
     QVERIFY(pointerEnteredSpy.wait());
     if (keyboardEnteredSpy.count() != 2) {
         QVERIFY(keyboardEnteredSpy.wait());
     }
     QCOMPARE(pointerLeftSpy.count(), 1);
     QCOMPARE(keyboardLeftSpy.count(), 1);
     QCOMPARE(pointerEnteredSpy.count(), 2);
     QCOMPARE(keyboardEnteredSpy.count(), 2);
 }
 
 void TestWindowSelection::testSelectPointTouch()
 {
     // this test verifies point selection through touch works
     QPoint point;
     auto callback = [&point] (const QPoint &p) {
         point = p;
     };
 
     // start the interaction
     QCOMPARE(input()->isSelectingWindow(), false);
     kwinApp()->platform()->startInteractivePositionSelection(callback);
     QCOMPARE(input()->isSelectingWindow(), true);
     QCOMPARE(point, QPoint());
 
     // let's create multiple touch points
     quint32 timestamp = 0;
     kwinApp()->platform()->touchDown(0, QPointF(0, 1), timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
     kwinApp()->platform()->touchDown(1, QPointF(10, 20), timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
     kwinApp()->platform()->touchDown(2, QPointF(30, 40), timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
 
     // let's move our points
     kwinApp()->platform()->touchMotion(0, QPointF(5, 10), timestamp++);
     kwinApp()->platform()->touchMotion(2, QPointF(20, 25), timestamp++);
     kwinApp()->platform()->touchMotion(1, QPointF(25, 35), timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
     kwinApp()->platform()->touchUp(2, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), true);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(input()->isSelectingWindow(), false);
     QCOMPARE(point, QPoint(25, 35));
 }
 
 WAYLANDTEST_MAIN(TestWindowSelection)
 #include "window_selection_test.moc"
diff --git a/autotests/integration/x11_client_test.cpp b/autotests/integration/x11_client_test.cpp
index 4d5750788..cee372e7b 100644
--- a/autotests/integration/x11_client_test.cpp
+++ b/autotests/integration/x11_client_test.cpp
@@ -1,1006 +1,1004 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "atoms.h"
 #include "x11client.h"
 #include "composite.h"
 #include "effects.h"
 #include "effectloader.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 static const QString s_socketName = QStringLiteral("wayland_test_x11_client-0");
 
 class X11ClientTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMinimumSize();
     void testMaximumSize();
     void testResizeIncrements();
     void testResizeIncrementsNoBaseSize();
     void testTrimCaption_data();
     void testTrimCaption();
     void testFullscreenLayerWithActiveWaylandWindow();
     void testFocusInWithWaylandLastActiveWindow();
     void testX11WindowId();
     void testCaptionChanges();
     void testCaptionWmName();
     void testCaptionMultipleWindows();
     void testFullscreenWindowGroups();
 };
 
 void X11ClientTest::initTestCase()
 {
     qRegisterMetaType<KWin::Deleted*>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
     waylandServer()->initWorkspace();
 }
 
 void X11ClientTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
 }
 
 void X11ClientTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void X11ClientTest::testMinimumSize()
 {
     // This test verifies that the minimum size constraint is correctly applied.
 
     // Create an xcb window.
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_min_size(&hints, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Begin resize.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
 
     client->keyPressEvent(Qt::Key_Left);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(-8, 0));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     QCOMPARE(client->clientSize().width(), 100);
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos);
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     QCOMPARE(client->clientSize().width(), 100);
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().width(), 108);
 
     client->keyPressEvent(Qt::Key_Up);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, -8));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().height(), 200);
 
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().height(), 200);
 
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 8));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->clientSize().height(), 208);
 
     // Finish the resize operation.
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
     c.reset();
 }
 
 void X11ClientTest::testMaximumSize()
 {
     // This test verifies that the maximum size constraint is correctly applied.
 
     // Create an xcb window.
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_max_size(&hints, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Begin resize.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     QCOMPARE(client->clientSize().width(), 100);
 
     client->keyPressEvent(Qt::Key_Left);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos);
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     QCOMPARE(client->clientSize().width(), 100);
 
     client->keyPressEvent(Qt::Key_Left);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(-8, 0));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().width(), 92);
 
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(-8, 8));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().height(), 200);
 
     client->keyPressEvent(Qt::Key_Up);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(-8, 0));
     QVERIFY(!clientStepUserMovedResizedSpy.wait(1000));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize().height(), 200);
 
     client->keyPressEvent(Qt::Key_Up);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(-8, -8));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->clientSize().height(), 192);
 
     // Finish the resize operation.
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
     c.reset();
 }
 
 void X11ClientTest::testResizeIncrements()
 {
     // This test verifies that the resize increments constraint is correctly applied.
 
     // Create an xcb window.
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_base_size(&hints, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_resize_inc(&hints, 3, 5);
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Begin resize.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize(), QSize(106, 200));
 
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 8));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->clientSize(), QSize(106, 205));
 
     // Finish the resize operation.
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
     c.reset();
 }
 
 void X11ClientTest::testResizeIncrementsNoBaseSize()
 {
     // Create an xcb window.
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_min_size(&hints, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_size_hints_set_resize_inc(&hints, 3, 5);
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Begin resize.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
 
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->clientSize(), QSize(106, 200));
 
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 8));
     QVERIFY(clientStepUserMovedResizedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->clientSize(), QSize(106, 205));
 
     // Finish the resize operation.
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 0);
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isResize());
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
     c.reset();
 }
 
 void X11ClientTest::testTrimCaption_data()
 {
     QTest::addColumn<QByteArray>("originalTitle");
     QTest::addColumn<QByteArray>("expectedTitle");
 
     QTest::newRow("simplified")
         << QByteArrayLiteral("Was tun, wenn Schüler Autismus haben?\342\200\250\342\200\250\342\200\250 – Marlies Hübner - Mozilla Firefox")
         << QByteArrayLiteral("Was tun, wenn Schüler Autismus haben? – Marlies Hübner - Mozilla Firefox");
 
     QTest::newRow("with emojis")
         << QByteArrayLiteral("\bTesting non\302\255printable:\177, emoij:\360\237\230\203, non-characters:\357\277\276")
         << QByteArrayLiteral("Testing nonprintable:, emoij:\360\237\230\203, non-characters:");
 }
 
 void X11ClientTest::testTrimCaption()
 {
     // this test verifies that caption is properly trimmed
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo winInfo(c.data(), w, rootWindow(), NET::Properties(), NET::Properties2());
     QFETCH(QByteArray, originalTitle);
     winInfo.setName(originalTitle);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QFETCH(QByteArray, expectedTitle);
     QCOMPARE(client->caption(), QString::fromUtf8(expectedTitle));
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 void X11ClientTest::testFullscreenLayerWithActiveWaylandWindow()
 {
     // this test verifies that an X11 fullscreen window does not stay in the active layer
     // when a Wayland window is active, see BUG: 375759
     QCOMPARE(screens()->count(), 1);
 
     // first create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(!client->isFullScreen());
     QVERIFY(client->isActive());
     QCOMPARE(client->layer(), NormalLayer);
 
     workspace()->slotWindowFullScreen();
     QVERIFY(client->isFullScreen());
     QCOMPARE(client->layer(), ActiveLayer);
     QCOMPARE(workspace()->stackingOrder().last(), client);
 
     // now let's open a Wayland window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto waylandClient = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(waylandClient);
     QVERIFY(waylandClient->isActive());
     QCOMPARE(waylandClient->layer(), NormalLayer);
     QCOMPARE(workspace()->stackingOrder().last(), waylandClient);
     QCOMPARE(workspace()->xStackingOrder().last(), waylandClient);
     QCOMPARE(client->layer(), NormalLayer);
 
     // now activate fullscreen again
     workspace()->activateClient(client);
     QTRY_VERIFY(client->isActive());
     QCOMPARE(client->layer(), ActiveLayer);
     QCOMPARE(workspace()->stackingOrder().last(), client);
     QCOMPARE(workspace()->xStackingOrder().last(), client);
 
     // activate wayland window again
     workspace()->activateClient(waylandClient);
     QTRY_VERIFY(waylandClient->isActive());
     QCOMPARE(workspace()->stackingOrder().last(), waylandClient);
     QCOMPARE(workspace()->xStackingOrder().last(), waylandClient);
 
     // back to x window
     workspace()->activateClient(client);
     QTRY_VERIFY(client->isActive());
     // remove fullscreen
     QVERIFY(client->isFullScreen());
     workspace()->slotWindowFullScreen();
     QVERIFY(!client->isFullScreen());
     // and fullscreen again
     workspace()->slotWindowFullScreen();
     QVERIFY(client->isFullScreen());
     QCOMPARE(workspace()->stackingOrder().last(), client);
     QCOMPARE(workspace()->xStackingOrder().last(), client);
 
     // activate wayland window again
     workspace()->activateClient(waylandClient);
     QTRY_VERIFY(waylandClient->isActive());
     QCOMPARE(workspace()->stackingOrder().last(), waylandClient);
     QCOMPARE(workspace()->xStackingOrder().last(), waylandClient);
 
     // back to X11 window
     workspace()->activateClient(client);
     QTRY_VERIFY(client->isActive());
     // remove fullscreen
     QVERIFY(client->isFullScreen());
     workspace()->slotWindowFullScreen();
     QVERIFY(!client->isFullScreen());
     // and fullscreen through X API
     NETWinInfo info(c.data(), w, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
     info.setState(NET::FullScreen, NET::FullScreen);
     NETRootInfo rootInfo(c.data(), NET::Properties());
     rootInfo.setActiveWindow(w, NET::FromApplication, XCB_CURRENT_TIME, XCB_WINDOW_NONE);
     xcb_flush(c.data());
     QTRY_VERIFY(client->isFullScreen());
     QCOMPARE(workspace()->stackingOrder().last(), client);
     QCOMPARE(workspace()->xStackingOrder().last(), client);
 
     // activate wayland window again
     workspace()->activateClient(waylandClient);
     QTRY_VERIFY(waylandClient->isActive());
     QCOMPARE(workspace()->stackingOrder().last(), waylandClient);
     QCOMPARE(workspace()->xStackingOrder().last(), waylandClient);
     QCOMPARE(client->layer(), NormalLayer);
 
     // close the window
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(waylandClient));
     QTRY_VERIFY(client->isActive());
     QCOMPARE(client->layer(), ActiveLayer);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 }
 
 void X11ClientTest::testFocusInWithWaylandLastActiveWindow()
 {
     // this test verifies that Workspace::allowClientActivation does not crash if last client was a Wayland client
 
     // create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isActive());
 
     // create Wayland window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto waylandClient = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(waylandClient);
     QVERIFY(waylandClient->isActive());
     // activate no window
     workspace()->setActiveClient(nullptr);
     QVERIFY(!waylandClient->isActive());
     QVERIFY(!workspace()->activeClient());
     // and close Wayland window again
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(waylandClient));
 
     // and try to activate the x11 client through X11 api
     const auto cookie = xcb_set_input_focus_checked(c.data(), XCB_INPUT_FOCUS_NONE, w, XCB_CURRENT_TIME);
     auto error = xcb_request_check(c.data(), cookie);
     QVERIFY(!error);
     // this accesses last_active_client on trying to activate
     QTRY_VERIFY(client->isActive());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 }
 
 void X11ClientTest::testX11WindowId()
 {
     // create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->windowId(), w);
     QVERIFY(client->isActive());
     QCOMPARE(client->window(), w);
     QCOMPARE(client->internalId().isNull(), false);
     const auto uuid = client->internalId();
     QUuid deletedUuid;
     QCOMPARE(deletedUuid.isNull(), true);
 
     connect(client, &X11Client::windowClosed, this, [&deletedUuid] (Toplevel *, Deleted *d) { deletedUuid = d->internalId(); });
 
 
     NETRootInfo rootInfo(c.data(), NET::WMAllProperties);
     QCOMPARE(rootInfo.activeWindow(), client->window());
 
     // activate a wayland window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto waylandClient = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(waylandClient);
     QVERIFY(waylandClient->isActive());
     xcb_flush(kwinApp()->x11Connection());
 
     NETRootInfo rootInfo2(c.data(), NET::WMAllProperties);
     QCOMPARE(rootInfo2.activeWindow(), 0u);
 
     // back to X11 client
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(waylandClient));
 
     QTRY_VERIFY(client->isActive());
     NETRootInfo rootInfo3(c.data(), NET::WMAllProperties);
     QCOMPARE(rootInfo3.activeWindow(), client->window());
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
 
     QCOMPARE(deletedUuid.isNull(), false);
     QCOMPARE(deletedUuid, uuid);
 }
 
 void X11ClientTest::testCaptionChanges()
 {
     // verifies that caption is updated correctly when the X11 window updates it
     // BUG: 383444
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
     info.setName("foo");
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->windowId(), w);
     QCOMPARE(client->caption(), QStringLiteral("foo"));
 
     QSignalSpy captionChangedSpy(client, &X11Client::captionChanged);
     QVERIFY(captionChangedSpy.isValid());
     info.setName("bar");
     xcb_flush(c.data());
     QVERIFY(captionChangedSpy.wait());
     QCOMPARE(client->caption(), QStringLiteral("bar"));
 
     // and destroy the window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 void X11ClientTest::testCaptionWmName()
 {
     // this test verifies that a caption set through WM_NAME is read correctly
 
     // open glxgears as that one only uses WM_NAME
     QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(clientAddedSpy.isValid());
 
     QProcess glxgears;
     glxgears.start(QStringLiteral("glxgears"));
     QVERIFY(glxgears.waitForStarted());
 
     QVERIFY(clientAddedSpy.wait());
     QCOMPARE(clientAddedSpy.count(), 1);
     QCOMPARE(workspace()->clientList().count(), 1);
     X11Client *glxgearsClient = workspace()->clientList().first();
     QCOMPARE(glxgearsClient->caption(), QStringLiteral("glxgears"));
 
     glxgears.terminate();
     QVERIFY(glxgears.waitForFinished());
 }
 
 void X11ClientTest::testCaptionMultipleWindows()
 {
     // BUG 384760
     // create first window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
     info.setName("foo");
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->windowId(), w);
     QCOMPARE(client->caption(), QStringLiteral("foo"));
 
     // create second window with same caption
     xcb_window_t w2 = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w2, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_icccm_set_wm_normal_hints(c.data(), w2, &hints);
     NETWinInfo info2(c.data(), w2, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
     info2.setName("foo");
     info2.setIconName("foo");
     xcb_map_window(c.data(), w2);
     xcb_flush(c.data());
 
     windowCreatedSpy.clear();
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client2);
     QCOMPARE(client2->windowId(), w2);
     QCOMPARE(client2->caption(), QStringLiteral("foo <2>\u200E"));
     NETWinInfo info3(kwinApp()->x11Connection(), w2, kwinApp()->x11RootWindow(), NET::WMVisibleName | NET::WMVisibleIconName, NET::Properties2());
     QCOMPARE(QByteArray(info3.visibleName()), QByteArrayLiteral("foo <2>\u200E"));
     QCOMPARE(QByteArray(info3.visibleIconName()), QByteArrayLiteral("foo <2>\u200E"));
 
     QSignalSpy captionChangedSpy(client2, &X11Client::captionChanged);
     QVERIFY(captionChangedSpy.isValid());
 
     NETWinInfo info4(c.data(), w2, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
     info4.setName("foobar");
     info4.setIconName("foobar");
     xcb_map_window(c.data(), w2);
     xcb_flush(c.data());
 
     QVERIFY(captionChangedSpy.wait());
     QCOMPARE(client2->caption(), QStringLiteral("foobar"));
     NETWinInfo info5(kwinApp()->x11Connection(), w2, kwinApp()->x11RootWindow(), NET::WMVisibleName | NET::WMVisibleIconName, NET::Properties2());
     QCOMPARE(QByteArray(info5.visibleName()), QByteArray());
     QTRY_COMPARE(QByteArray(info5.visibleIconName()), QByteArray());
 }
 
 
 void X11ClientTest::testFullscreenWindowGroups()
 {
     // this test creates an X11 window and puts it to full screen
     // then a second window is created which is in the same window group
     // BUG: 388310
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w, atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &w);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->windowId(), w);
     QCOMPARE(client->isActive(), true);
 
     QCOMPARE(client->isFullScreen(), false);
     QCOMPARE(client->layer(), NormalLayer);
     workspace()->slotWindowFullScreen();
     QCOMPARE(client->isFullScreen(), true);
     QCOMPARE(client->layer(), ActiveLayer);
 
     // now let's create a second window
     windowCreatedSpy.clear();
     xcb_window_t w2 = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w2, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints2;
     memset(&hints2, 0, sizeof(hints2));
     xcb_icccm_size_hints_set_position(&hints2, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints2, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w2, &hints2);
     xcb_change_property(c.data(), XCB_PROP_MODE_REPLACE, w2, atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &w);
     xcb_map_window(c.data(), w2);
     xcb_flush(c.data());
 
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client2 = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client2);
     QVERIFY(client != client2);
     QCOMPARE(client2->windowId(), w2);
     QCOMPARE(client2->isActive(), true);
     QCOMPARE(client2->group(), client->group());
     // first client should be moved back to normal layer
     QCOMPARE(client->isActive(), false);
     QCOMPARE(client->isFullScreen(), true);
     QCOMPARE(client->layer(), NormalLayer);
 
     // activating the fullscreen window again, should move it to active layer
     workspace()->activateClient(client);
     QTRY_COMPARE(client->layer(), ActiveLayer);
 }
 
 WAYLANDTEST_MAIN(X11ClientTest)
 #include "x11_client_test.moc"
diff --git a/autotests/integration/xdgshellclient_rules_test.cpp b/autotests/integration/xdgshellclient_rules_test.cpp
index 46dfc81b1..2743156aa 100644
--- a/autotests/integration/xdgshellclient_rules_test.cpp
+++ b/autotests/integration/xdgshellclient_rules_test.cpp
@@ -1,4544 +1,4543 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "kwin_wayland_test.h"
 
+#include "abstract_client.h"
 #include "cursor.h"
 #include "platform.h"
 #include "rules.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xdgshellclient_rules-0");
 
 class TestXdgShellClientRules : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testPositionDontAffect_data();
     void testPositionDontAffect();
     void testPositionApply_data();
     void testPositionApply();
     void testPositionRemember_data();
     void testPositionRemember();
     void testPositionForce_data();
     void testPositionForce();
     void testPositionApplyNow_data();
     void testPositionApplyNow();
     void testPositionForceTemporarily_data();
     void testPositionForceTemporarily();
 
     void testSizeDontAffect_data();
     void testSizeDontAffect();
     void testSizeApply_data();
     void testSizeApply();
     void testSizeRemember_data();
     void testSizeRemember();
     void testSizeForce_data();
     void testSizeForce();
     void testSizeApplyNow_data();
     void testSizeApplyNow();
     void testSizeForceTemporarily_data();
     void testSizeForceTemporarily();
 
     void testMaximizeDontAffect_data();
     void testMaximizeDontAffect();
     void testMaximizeApply_data();
     void testMaximizeApply();
     void testMaximizeRemember_data();
     void testMaximizeRemember();
     void testMaximizeForce_data();
     void testMaximizeForce();
     void testMaximizeApplyNow_data();
     void testMaximizeApplyNow();
     void testMaximizeForceTemporarily_data();
     void testMaximizeForceTemporarily();
 
     void testDesktopDontAffect_data();
     void testDesktopDontAffect();
     void testDesktopApply_data();
     void testDesktopApply();
     void testDesktopRemember_data();
     void testDesktopRemember();
     void testDesktopForce_data();
     void testDesktopForce();
     void testDesktopApplyNow_data();
     void testDesktopApplyNow();
     void testDesktopForceTemporarily_data();
     void testDesktopForceTemporarily();
 
     void testMinimizeDontAffect_data();
     void testMinimizeDontAffect();
     void testMinimizeApply_data();
     void testMinimizeApply();
     void testMinimizeRemember_data();
     void testMinimizeRemember();
     void testMinimizeForce_data();
     void testMinimizeForce();
     void testMinimizeApplyNow_data();
     void testMinimizeApplyNow();
     void testMinimizeForceTemporarily_data();
     void testMinimizeForceTemporarily();
 
     void testSkipTaskbarDontAffect_data();
     void testSkipTaskbarDontAffect();
     void testSkipTaskbarApply_data();
     void testSkipTaskbarApply();
     void testSkipTaskbarRemember_data();
     void testSkipTaskbarRemember();
     void testSkipTaskbarForce_data();
     void testSkipTaskbarForce();
     void testSkipTaskbarApplyNow_data();
     void testSkipTaskbarApplyNow();
     void testSkipTaskbarForceTemporarily_data();
     void testSkipTaskbarForceTemporarily();
 
     void testSkipPagerDontAffect_data();
     void testSkipPagerDontAffect();
     void testSkipPagerApply_data();
     void testSkipPagerApply();
     void testSkipPagerRemember_data();
     void testSkipPagerRemember();
     void testSkipPagerForce_data();
     void testSkipPagerForce();
     void testSkipPagerApplyNow_data();
     void testSkipPagerApplyNow();
     void testSkipPagerForceTemporarily_data();
     void testSkipPagerForceTemporarily();
 
     void testSkipSwitcherDontAffect_data();
     void testSkipSwitcherDontAffect();
     void testSkipSwitcherApply_data();
     void testSkipSwitcherApply();
     void testSkipSwitcherRemember_data();
     void testSkipSwitcherRemember();
     void testSkipSwitcherForce_data();
     void testSkipSwitcherForce();
     void testSkipSwitcherApplyNow_data();
     void testSkipSwitcherApplyNow();
     void testSkipSwitcherForceTemporarily_data();
     void testSkipSwitcherForceTemporarily();
 
     void testKeepAboveDontAffect_data();
     void testKeepAboveDontAffect();
     void testKeepAboveApply_data();
     void testKeepAboveApply();
     void testKeepAboveRemember_data();
     void testKeepAboveRemember();
     void testKeepAboveForce_data();
     void testKeepAboveForce();
     void testKeepAboveApplyNow_data();
     void testKeepAboveApplyNow();
     void testKeepAboveForceTemporarily_data();
     void testKeepAboveForceTemporarily();
 
     void testKeepBelowDontAffect_data();
     void testKeepBelowDontAffect();
     void testKeepBelowApply_data();
     void testKeepBelowApply();
     void testKeepBelowRemember_data();
     void testKeepBelowRemember();
     void testKeepBelowForce_data();
     void testKeepBelowForce();
     void testKeepBelowApplyNow_data();
     void testKeepBelowApplyNow();
     void testKeepBelowForceTemporarily_data();
     void testKeepBelowForceTemporarily();
 
     void testShortcutDontAffect_data();
     void testShortcutDontAffect();
     void testShortcutApply_data();
     void testShortcutApply();
     void testShortcutRemember_data();
     void testShortcutRemember();
     void testShortcutForce_data();
     void testShortcutForce();
     void testShortcutApplyNow_data();
     void testShortcutApplyNow();
     void testShortcutForceTemporarily_data();
     void testShortcutForceTemporarily();
 
     void testDesktopFileDontAffect_data();
     void testDesktopFileDontAffect();
     void testDesktopFileApply_data();
     void testDesktopFileApply();
     void testDesktopFileRemember_data();
     void testDesktopFileRemember();
     void testDesktopFileForce_data();
     void testDesktopFileForce();
     void testDesktopFileApplyNow_data();
     void testDesktopFileApplyNow();
     void testDesktopFileForceTemporarily_data();
     void testDesktopFileForceTemporarily();
 
     void testActiveOpacityDontAffect_data();
     void testActiveOpacityDontAffect();
     void testActiveOpacityForce_data();
     void testActiveOpacityForce();
     void testActiveOpacityForceTemporarily_data();
     void testActiveOpacityForceTemporarily();
 
     void testInactiveOpacityDontAffect_data();
     void testInactiveOpacityDontAffect();
     void testInactiveOpacityForce_data();
     void testInactiveOpacityForce();
     void testInactiveOpacityForceTemporarily_data();
     void testInactiveOpacityForceTemporarily();
 
     void testMatchAfterNameChange();
 };
 
 void TestXdgShellClientRules::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient *>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestXdgShellClientRules::init()
 {
     VirtualDesktopManager::self()->setCurrent(VirtualDesktopManager::self()->desktops().first());
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     screens()->setCurrent(0);
 }
 
 void TestXdgShellClientRules::cleanup()
 {
     Test::destroyWaylandConnection();
 
     // Unreference the previous config.
     RuleBook::self()->setConfig({});
     workspace()->slotReconfigure();
 
     // Restore virtual desktops to the initial state.
     VirtualDesktopManager::self()->setCount(1);
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
 }
 
 #define TEST_DATA(name) \
 void TestXdgShellClientRules::name##_data() \
 { \
     QTest::addColumn<Test::XdgShellSurfaceType>("type"); \
     QTest::newRow("XdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6; \
     QTest::newRow("XdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable; \
 }
 
-std::tuple<XdgShellClient *, Surface *, XdgShellSurface *> createWindow(Test::XdgShellSurfaceType type, const QByteArray &appId)
+std::tuple<AbstractClient *, Surface *, XdgShellSurface *> createWindow(Test::XdgShellSurfaceType type, const QByteArray &appId)
 {
     // Create an xdg surface.
     Surface *surface = Test::createSurface();
     XdgShellSurface *shellSurface = Test::createXdgShellSurface(type, surface, surface, Test::CreationSetup::CreateOnly);
 
     // Assign the desired app id.
     shellSurface->setAppId(appId);
 
     // Wait for the initial configure event.
     QSignalSpy configureRequestedSpy(shellSurface, &XdgShellSurface::configureRequested);
     surface->commit(Surface::CommitFlag::None);
     configureRequestedSpy.wait();
 
     // Draw content of the surface.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
 
     return {client, surface, shellSurface};
 }
 
 TEST_DATA(testPositionDontAffect)
 
 void TestXdgShellClientRules::testPositionDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The position of the client should not be affected by the rule. The default
     // placement policy will put the client in the top-left corner of the screen.
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(0, 0));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testPositionApply)
 
 void TestXdgShellClientRules::testPositionApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The client should be moved to the position specified by the rule.
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // One should still be able to move the client around.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isMove());
     QVERIFY(!client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     // The rule should be applied again if the client appears after it's been closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testPositionRemember)
 
 void TestXdgShellClientRules::testPositionRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The client should be moved to the position specified by the rule.
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // One should still be able to move the client around.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isMove());
     QVERIFY(!client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     // The client should be placed at the last know position if we reopen it.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testPositionForce)
 
 void TestXdgShellClientRules::testPositionForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The client should be moved to the position specified by the rule.
     QVERIFY(!client->isMovable());
     QVERIFY(!client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // User should not be able to move the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(clientStartMoveResizedSpy.count(), 0);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
 
     // The position should still be forced if we reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isMovable());
     QVERIFY(!client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testPositionApplyNow)
 
 void TestXdgShellClientRules::testPositionApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     QObject *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The position of the client isn't set by any rule, thus the default placement
     // policy will try to put the client in the top-left corner of the screen.
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(0, 0));
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
 
     // The client should be moved to the position specified by the rule.
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     workspace()->slotReconfigure();
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // We still have to be able to move the client around.
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(client->isMove());
     QVERIFY(!client->isResize());
 
     const QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QCOMPARE(client->pos(), QPoint(50, 42));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testPositionForceTemporarily)
 
 void TestXdgShellClientRules::testPositionForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("position", QPoint(42, 42));
     group.writeEntry("positionrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The client should be moved to the position specified by the rule.
     QVERIFY(!client->isMovable());
     QVERIFY(!client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(42, 42));
 
     // User should not be able to move the client.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(clientStartMoveResizedSpy.count(), 0);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
 
     // The rule should be discarded if we close the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QCOMPARE(client->pos(), QPoint(0, 0));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeDontAffect)
 
 void TestXdgShellClientRules::testSizeDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The window size shouldn't be enforced by the rule.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(0, 0));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(100, 50));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeApply)
 
 void TestXdgShellClientRules::testSizeApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The initial configure event should contain size hint set by the rule.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(480, 640));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // One still should be able to resize the client.
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
     QSignalSpy surfaceSizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(surfaceSizeChangedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(!client->isMove());
     QVERIFY(client->isResize());
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
 
     const QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 4);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(surfaceSizeChangedSpy.count(), 1);
     QCOMPARE(surfaceSizeChangedSpy.last().first().toSize(), QSize(488, 640));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(488, 640), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(488, 640));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
 
     QEXPECT_FAIL("", "Interactive resize is not spec-compliant", Continue);
     QVERIFY(configureRequestedSpy->wait(10));
     QEXPECT_FAIL("", "Interactive resize is not spec-compliant", Continue);
     QCOMPARE(configureRequestedSpy->count(), 5);
 
     // The rule should be applied again if the client appears after it's been closed.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeRemember)
 
 void TestXdgShellClientRules::testSizeRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The initial configure event should contain size hint set by the rule.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 
     // One should still be able to resize the client.
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
     QSignalSpy surfaceSizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(surfaceSizeChangedSpy.isValid());
 
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(!client->isMove());
     QVERIFY(client->isResize());
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
 
     const QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 4);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(surfaceSizeChangedSpy.count(), 1);
     QCOMPARE(surfaceSizeChangedSpy.last().first().toSize(), QSize(488, 640));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 0);
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(488, 640), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(488, 640));
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
 
     QEXPECT_FAIL("", "Interactive resize is not spec-compliant", Continue);
     QVERIFY(configureRequestedSpy->wait(10));
     QEXPECT_FAIL("", "Interactive resize is not spec-compliant", Continue);
     QCOMPARE(configureRequestedSpy->count(), 5);
 
     // If the client appears again, it should have the last known size.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(488, 640));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(488, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(488, 640));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeForce)
 
 void TestXdgShellClientRules::testSizeForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The initial configure event should contain size hint set by the rule.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Any attempt to resize the client should not succeed.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(clientStartMoveResizedSpy.count(), 0);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     QVERIFY(!configureRequestedSpy->wait(100));
 
     // If the client appears again, the size should still be forced.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeApplyNow)
 
 void TestXdgShellClientRules::testSizeApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The expected surface dimensions should be set by the rule.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(0, 0));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(100, 50));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The compositor should send a configure event with a new size.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
 
     // Draw the surface with the new size.
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(480, 640));
     QVERIFY(!configureRequestedSpy->wait(100));
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!configureRequestedSpy->wait(100));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSizeForceTemporarily)
 
 void TestXdgShellClientRules::testSizeForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("size", QSize(480, 640));
     group.writeEntry("sizerule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // The initial configure event should contain size hint set by the rule.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(480, 640));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(480, 640), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isResizable());
     QCOMPARE(client->size(), QSize(480, 640));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Any attempt to resize the client should not succeed.
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     QCOMPARE(clientStartMoveResizedSpy.count(), 0);
     QVERIFY(!client->isMove());
     QVERIFY(!client->isResize());
     QVERIFY(!configureRequestedSpy->wait(100));
 
     // The rule should be discarded when the client is closed.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().first().toSize(), QSize(0, 0));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isResizable());
     QCOMPARE(client->size(), QSize(100, 50));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeDontAffect)
 
 void TestXdgShellClientRules::testMaximizeDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::DontAffect));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->size(), QSize(100, 50));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeApply)
 
 void TestXdgShellClientRules::testMaximizeApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::Apply));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // One should still be able to change the maximized state of the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(100, 50));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
 
     // If we create the client again, it should be initially maximized.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeRemember)
 
 void TestXdgShellClientRules::testMaximizeRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::Remember));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // One should still be able to change the maximized state of the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(100, 50));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
 
     // If we create the client again, it should not be maximized (because last time it wasn't).
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->size(), QSize(100, 50));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeForce)
 
 void TestXdgShellClientRules::testMaximizeForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::Force));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Any attempt to change the maximized state should not succeed.
     const QRect oldGeometry = client->frameGeometry();
     workspace()->slotWindowMaximize();
     QVERIFY(!configureRequestedSpy->wait(100));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->frameGeometry(), oldGeometry);
 
     // If we create the client again, the maximized state should still be forced.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeApplyNow)
 
 void TestXdgShellClientRules::testMaximizeApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->size(), QSize(100, 50));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::ApplyNow));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We should receive a configure event with a new surface size.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 3);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Draw contents of the maximized client.
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(1280, 1024));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
 
     // The client still has to be maximizeable.
     QVERIFY(client->isMaximizable());
 
     // Restore the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 4);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(100, 50));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->size(), QSize(100, 50));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
 
     // The rule should be discarded after it's been applied.
     const QRect oldGeometry = client->frameGeometry();
     client->evaluateWindowRules();
     QVERIFY(!configureRequestedSpy->wait(100));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->frameGeometry(), oldGeometry);
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMaximizeForceTemporarily)
 
 void TestXdgShellClientRules::testMaximizeForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("maximizehoriz", true);
     group.writeEntry("maximizehorizrule", int(Rules::ForceTemporarily));
     group.writeEntry("maximizevert", true);
     group.writeEntry("maximizevertrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<Surface> surface;
     surface.reset(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface;
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<QSignalSpy> configureRequestedSpy;
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(!client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->size(), QSize(1280, 1024));
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Any attempt to change the maximized state should not succeed.
     const QRect oldGeometry = client->frameGeometry();
     workspace()->slotWindowMaximize();
     QVERIFY(!configureRequestedSpy->wait(100));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->frameGeometry(), oldGeometry);
 
     // The rule should be discarded if we close the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     surface.reset(Test::createSurface());
     shellSurface.reset(createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     configureRequestedSpy.reset(new QSignalSpy(shellSurface.data(), &XdgShellSurface::configureRequested));
     shellSurface->setAppId("org.kde.foo");
     surface->commit(Surface::CommitFlag::None);
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 1);
     QCOMPARE(configureRequestedSpy->last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy->last().at(2).value<quint32>());
     client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QVERIFY(client->isMaximizable());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->size(), QSize(100, 50));
 
     QVERIFY(configureRequestedSpy->wait());
     QCOMPARE(configureRequestedSpy->count(), 2);
     states = configureRequestedSpy->last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Destroy the client.
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopDontAffect)
 
 void TestXdgShellClientRules::testDesktopDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should appear on the current virtual desktop.
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopApply)
 
 void TestXdgShellClientRules::testDesktopApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should appear on the second virtual desktop.
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // We still should be able to move the client between desktops.
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // If we re-open the client, it should appear on the second virtual desktop again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopRemember)
 
 void TestXdgShellClientRules::testDesktopRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // Move the client to the first virtual desktop.
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // If we create the client again, it should appear on the first virtual desktop.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopForce)
 
 void TestXdgShellClientRules::testDesktopForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should appear on the second virtual desktop.
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // Any attempt to move the client to another virtual desktop should fail.
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // If we re-open the client, it should appear on the second virtual desktop again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopApplyNow)
 
 void TestXdgShellClientRules::testDesktopApplyNow()
 {
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should have been moved to the second virtual desktop.
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // One should still be able to move the client between desktops.
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopForceTemporarily)
 
 void TestXdgShellClientRules::testDesktopForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("desktop", 2);
     group.writeEntry("desktoprule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // We need at least two virtual desktop for this test.
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should appear on the second virtual desktop.
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // Any attempt to move the client to another virtual desktop should fail.
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 2);
 
     // The rule should be discarded when the client is withdrawn.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     VirtualDesktopManager::self()->setCurrent(1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // One should be able to move the client between desktops.
     workspace()->sendClientToDesktop(client, 2, true);
     QCOMPARE(client->desktop(), 2);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
     workspace()->sendClientToDesktop(client, 1, true);
     QCOMPARE(client->desktop(), 1);
     QCOMPARE(VirtualDesktopManager::self()->current(), 1);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeDontAffect)
 
 void TestXdgShellClientRules::testMinimizeDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", true);
     group.writeEntry("minimizerule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
 
     // The client should not be minimized.
     QVERIFY(!client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeApply)
 
 void TestXdgShellClientRules::testMinimizeApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", true);
     group.writeEntry("minimizerule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
 
     // The client should be minimized.
     QVERIFY(client->isMinimized());
 
     // We should still be able to unminimize the client.
     client->unminimize();
     QVERIFY(!client->isMinimized());
 
     // If we re-open the client, it should be minimized back again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
     QVERIFY(client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeRemember)
 
 void TestXdgShellClientRules::testMinimizeRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", false);
     group.writeEntry("minimizerule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
     QVERIFY(!client->isMinimized());
 
     // Minimize the client.
     client->minimize();
     QVERIFY(client->isMinimized());
 
     // If we open the client again, it should be minimized.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
     QVERIFY(client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeForce)
 
 void TestXdgShellClientRules::testMinimizeForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", false);
     group.writeEntry("minimizerule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->isMinimizable());
     QVERIFY(!client->isMinimized());
 
     // Any attempt to minimize the client should fail.
     client->minimize();
     QVERIFY(!client->isMinimized());
 
     // If we re-open the client, the minimized state should still be forced.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->isMinimizable());
     QVERIFY(!client->isMinimized());
     client->minimize();
     QVERIFY(!client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeApplyNow)
 
 void TestXdgShellClientRules::testMinimizeApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
     QVERIFY(!client->isMinimized());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", true);
     group.writeEntry("minimizerule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should be minimized now.
     QVERIFY(client->isMinimizable());
     QVERIFY(client->isMinimized());
 
     // One is still able to unminimize the client.
     client->unminimize();
     QVERIFY(!client->isMinimized());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(client->isMinimizable());
     QVERIFY(!client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testMinimizeForceTemporarily)
 
 void TestXdgShellClientRules::testMinimizeForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("minimize", false);
     group.writeEntry("minimizerule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->isMinimizable());
     QVERIFY(!client->isMinimized());
 
     // Any attempt to minimize the client should fail until the client is closed.
     client->minimize();
     QVERIFY(!client->isMinimized());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isMinimizable());
     QVERIFY(!client->isMinimized());
     client->minimize();
     QVERIFY(client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarDontAffect)
 
 void TestXdgShellClientRules::testSkipTaskbarDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be affected by the rule.
     QVERIFY(!client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarApply)
 
 void TestXdgShellClientRules::testSkipTaskbarApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a taskbar.
     QVERIFY(client->skipTaskbar());
 
     // Though one can change that.
     client->setOriginalSkipTaskbar(false);
     QVERIFY(!client->skipTaskbar());
 
     // Reopen the client, the rule should be applied again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarRemember)
 
 void TestXdgShellClientRules::testSkipTaskbarRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a taskbar.
     QVERIFY(client->skipTaskbar());
 
     // Change the skip-taskbar state.
     client->setOriginalSkipTaskbar(false);
     QVERIFY(!client->skipTaskbar());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be included on a taskbar.
     QVERIFY(!client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarForce)
 
 void TestXdgShellClientRules::testSkipTaskbarForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a taskbar.
     QVERIFY(client->skipTaskbar());
 
     // Any attempt to change the skip-taskbar state should not succeed.
     client->setOriginalSkipTaskbar(false);
     QVERIFY(client->skipTaskbar());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The skip-taskbar state should be still forced.
     QVERIFY(client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarApplyNow)
 
 void TestXdgShellClientRules::testSkipTaskbarApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipTaskbar());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should not be on a taskbar now.
     QVERIFY(client->skipTaskbar());
 
     // Also, one change the skip-taskbar state.
     client->setOriginalSkipTaskbar(false);
     QVERIFY(!client->skipTaskbar());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipTaskbarForceTemporarily)
 
 void TestXdgShellClientRules::testSkipTaskbarForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skiptaskbar", true);
     group.writeEntry("skiptaskbarrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a taskbar.
     QVERIFY(client->skipTaskbar());
 
     // Any attempt to change the skip-taskbar state should not succeed.
     client->setOriginalSkipTaskbar(false);
     QVERIFY(client->skipTaskbar());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipTaskbar());
 
     // The skip-taskbar state is no longer forced.
     client->setOriginalSkipTaskbar(true);
     QVERIFY(client->skipTaskbar());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerDontAffect)
 
 void TestXdgShellClientRules::testSkipPagerDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be affected by the rule.
     QVERIFY(!client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerApply)
 
 void TestXdgShellClientRules::testSkipPagerApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a pager.
     QVERIFY(client->skipPager());
 
     // Though one can change that.
     client->setSkipPager(false);
     QVERIFY(!client->skipPager());
 
     // Reopen the client, the rule should be applied again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerRemember)
 
 void TestXdgShellClientRules::testSkipPagerRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a pager.
     QVERIFY(client->skipPager());
 
     // Change the skip-pager state.
     client->setSkipPager(false);
     QVERIFY(!client->skipPager());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be included on a pager.
     QVERIFY(!client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerForce)
 
 void TestXdgShellClientRules::testSkipPagerForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a pager.
     QVERIFY(client->skipPager());
 
     // Any attempt to change the skip-pager state should not succeed.
     client->setSkipPager(false);
     QVERIFY(client->skipPager());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The skip-pager state should be still forced.
     QVERIFY(client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerApplyNow)
 
 void TestXdgShellClientRules::testSkipPagerApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipPager());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should not be on a pager now.
     QVERIFY(client->skipPager());
 
     // Also, one change the skip-pager state.
     client->setSkipPager(false);
     QVERIFY(!client->skipPager());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipPagerForceTemporarily)
 
 void TestXdgShellClientRules::testSkipPagerForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skippager", true);
     group.writeEntry("skippagerrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be included on a pager.
     QVERIFY(client->skipPager());
 
     // Any attempt to change the skip-pager state should not succeed.
     client->setSkipPager(false);
     QVERIFY(client->skipPager());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipPager());
 
     // The skip-pager state is no longer forced.
     client->setSkipPager(true);
     QVERIFY(client->skipPager());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherDontAffect)
 
 void TestXdgShellClientRules::testSkipSwitcherDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should not be affected by the rule.
     QVERIFY(!client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherApply)
 
 void TestXdgShellClientRules::testSkipSwitcherApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be excluded from window switching effects.
     QVERIFY(client->skipSwitcher());
 
     // Though one can change that.
     client->setSkipSwitcher(false);
     QVERIFY(!client->skipSwitcher());
 
     // Reopen the client, the rule should be applied again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherRemember)
 
 void TestXdgShellClientRules::testSkipSwitcherRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be excluded from window switching effects.
     QVERIFY(client->skipSwitcher());
 
     // Change the skip-switcher state.
     client->setSkipSwitcher(false);
     QVERIFY(!client->skipSwitcher());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be included in window switching effects.
     QVERIFY(!client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherForce)
 
 void TestXdgShellClientRules::testSkipSwitcherForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be excluded from window switching effects.
     QVERIFY(client->skipSwitcher());
 
     // Any attempt to change the skip-switcher state should not succeed.
     client->setSkipSwitcher(false);
     QVERIFY(client->skipSwitcher());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The skip-switcher state should be still forced.
     QVERIFY(client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherApplyNow)
 
 void TestXdgShellClientRules::testSkipSwitcherApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipSwitcher());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should be excluded from window switching effects now.
     QVERIFY(client->skipSwitcher());
 
     // Also, one change the skip-switcher state.
     client->setSkipSwitcher(false);
     QVERIFY(!client->skipSwitcher());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testSkipSwitcherForceTemporarily)
 
 void TestXdgShellClientRules::testSkipSwitcherForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("skipswitcher", true);
     group.writeEntry("skipswitcherrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The client should be excluded from window switching effects.
     QVERIFY(client->skipSwitcher());
 
     // Any attempt to change the skip-switcher state should not succeed.
     client->setSkipSwitcher(false);
     QVERIFY(client->skipSwitcher());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->skipSwitcher());
 
     // The skip-switcher state is no longer forced.
     client->setSkipSwitcher(true);
     QVERIFY(client->skipSwitcher());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveDontAffect)
 
 void TestXdgShellClientRules::testKeepAboveDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The keep-above state of the client should not be affected by the rule.
     QVERIFY(!client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveApply)
 
 void TestXdgShellClientRules::testKeepAboveApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept above.
     QVERIFY(client->keepAbove());
 
     // One should also be able to alter the keep-above state.
     client->setKeepAbove(false);
     QVERIFY(!client->keepAbove());
 
     // If one re-opens the client, it should be kept above back again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveRemember)
 
 void TestXdgShellClientRules::testKeepAboveRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept above.
     QVERIFY(client->keepAbove());
 
     // Unset the keep-above state.
     client->setKeepAbove(false);
     QVERIFY(!client->keepAbove());
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 
     // Re-open the client, it should not be kept above.
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveForce)
 
 void TestXdgShellClientRules::testKeepAboveForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept above.
     QVERIFY(client->keepAbove());
 
     // Any attemt to unset the keep-above should not succeed.
     client->setKeepAbove(false);
     QVERIFY(client->keepAbove());
 
     // If we re-open the client, it should still be kept above.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveApplyNow)
 
 void TestXdgShellClientRules::testKeepAboveApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepAbove());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should now be kept above other clients.
     QVERIFY(client->keepAbove());
 
     // One is still able to change the keep-above state of the client.
     client->setKeepAbove(false);
     QVERIFY(!client->keepAbove());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepAboveForceTemporarily)
 
 void TestXdgShellClientRules::testKeepAboveForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept above.
     QVERIFY(client->keepAbove());
 
     // Any attempt to alter the keep-above state should not succeed.
     client->setKeepAbove(false);
     QVERIFY(client->keepAbove());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepAbove());
 
     // The keep-above state is no longer forced.
     client->setKeepAbove(true);
     QVERIFY(client->keepAbove());
     client->setKeepAbove(false);
     QVERIFY(!client->keepAbove());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowDontAffect)
 
 void TestXdgShellClientRules::testKeepBelowDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The keep-below state of the client should not be affected by the rule.
     QVERIFY(!client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowApply)
 
 void TestXdgShellClientRules::testKeepBelowApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept below.
     QVERIFY(client->keepBelow());
 
     // One should also be able to alter the keep-below state.
     client->setKeepBelow(false);
     QVERIFY(!client->keepBelow());
 
     // If one re-opens the client, it should be kept above back again.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowRemember)
 
 void TestXdgShellClientRules::testKeepBelowRemember()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept below.
     QVERIFY(client->keepBelow());
 
     // Unset the keep-below state.
     client->setKeepBelow(false);
     QVERIFY(!client->keepBelow());
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 
     // Re-open the client, it should not be kept below.
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowForce)
 
 void TestXdgShellClientRules::testKeepBelowForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept below.
     QVERIFY(client->keepBelow());
 
     // Any attemt to unset the keep-below should not succeed.
     client->setKeepBelow(false);
     QVERIFY(client->keepBelow());
 
     // If we re-open the client, it should still be kept below.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowApplyNow)
 
 void TestXdgShellClientRules::testKeepBelowApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepBelow());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should now be kept below other clients.
     QVERIFY(client->keepBelow());
 
     // One is still able to change the keep-below state of the client.
     client->setKeepBelow(false);
     QVERIFY(!client->keepBelow());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QVERIFY(!client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testKeepBelowForceTemporarily)
 
 void TestXdgShellClientRules::testKeepBelowForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("below", true);
     group.writeEntry("belowrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // Initially, the client should be kept below.
     QVERIFY(client->keepBelow());
 
     // Any attempt to alter the keep-below state should not succeed.
     client->setKeepBelow(false);
     QVERIFY(client->keepBelow());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(!client->keepBelow());
 
     // The keep-below state is no longer forced.
     client->setKeepBelow(true);
     QVERIFY(client->keepBelow());
     client->setKeepBelow(false);
     QVERIFY(!client->keepBelow());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutDontAffect)
 
 void TestXdgShellClientRules::testShortcutDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QCOMPARE(client->shortcut(), QKeySequence());
     client->minimize();
     QVERIFY(client->isMinimized());
 
     // If we press the window shortcut, nothing should happen.
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(!clientUnminimizedSpy.wait(100));
     QVERIFY(client->isMinimized());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutApply)
 
 void TestXdgShellClientRules::testShortcutApply()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::Apply));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // If we press the window shortcut, the window should be brought back to user.
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // One can also change the shortcut.
     client->setShortcut(QStringLiteral("Ctrl+Alt+2"));
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_2}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // The old shortcut should do nothing.
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(!clientUnminimizedSpy.wait(100));
     QVERIFY(client->isMinimized());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The window shortcut should be set back to Ctrl+Alt+1.
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutRemember)
 
 void TestXdgShellClientRules::testShortcutRemember()
 {
     QSKIP("KWin core doesn't try to save the last used window shortcut");
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::Remember));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // If we press the window shortcut, the window should be brought back to user.
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // Change the window shortcut to Ctrl+Alt+2.
     client->setShortcut(QStringLiteral("Ctrl+Alt+2"));
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_2}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The window shortcut should be set to the last known value.
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_2}));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutForce)
 
 void TestXdgShellClientRules::testShortcutForce()
 {
     QSKIP("KWin core can't release forced window shortcuts");
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // If we press the window shortcut, the window should be brought back to user.
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // Any attempt to change the window shortcut should not succeed.
     client->setShortcut(QStringLiteral("Ctrl+Alt+2"));
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(!clientUnminimizedSpy.wait(100));
     QVERIFY(client->isMinimized());
 
     // Reopen the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // The window shortcut should still be forced.
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutApplyNow)
 
 void TestXdgShellClientRules::testShortcutApplyNow()
 {
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->shortcut().isEmpty());
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::ApplyNow));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // The client should now have a window shortcut assigned.
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // Assign a different shortcut.
     client->setShortcut(QStringLiteral("Ctrl+Alt+2"));
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_2}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // The rule should not be applied again.
     client->evaluateWindowRules();
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_2}));
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testShortcutForceTemporarily)
 
 void TestXdgShellClientRules::testShortcutForceTemporarily()
 {
     QSKIP("KWin core can't release forced window shortcuts");
 
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("shortcut", "Ctrl+Alt+1");
     group.writeEntry("shortcutrule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
 
     // If we press the window shortcut, the window should be brought back to user.
     QSignalSpy clientUnminimizedSpy(client, &AbstractClient::clientUnminimized);
     QVERIFY(clientUnminimizedSpy.isValid());
     quint32 timestamp = 1;
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(clientUnminimizedSpy.wait());
     QVERIFY(!client->isMinimized());
 
     // Any attempt to change the window shortcut should not succeed.
     client->setShortcut(QStringLiteral("Ctrl+Alt+2"));
     QCOMPARE(client->shortcut(), (QKeySequence{Qt::CTRL + Qt::ALT + Qt::Key_1}));
     client->minimize();
     QVERIFY(client->isMinimized());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
     QVERIFY(!clientUnminimizedSpy.wait(100));
     QVERIFY(client->isMinimized());
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->shortcut().isEmpty());
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testDesktopFileDontAffect)
 
 void TestXdgShellClientRules::testDesktopFileDontAffect()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testDesktopFileApply)
 
 void TestXdgShellClientRules::testDesktopFileApply()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testDesktopFileRemember)
 
 void TestXdgShellClientRules::testDesktopFileRemember()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testDesktopFileForce)
 
 void TestXdgShellClientRules::testDesktopFileForce()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testDesktopFileApplyNow)
 
 void TestXdgShellClientRules::testDesktopFileApplyNow()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testDesktopFileForceTemporarily)
 
 void TestXdgShellClientRules::testDesktopFileForceTemporarily()
 {
     // Currently, the desktop file name is derived from the app id. If the app id is
     // changed, then the old rules will be lost. Either setDesktopFileName should
     // be exposed or the desktop file name rule should be removed for wayland clients.
     QSKIP("Needs changes in KWin core to pass");
 }
 
 TEST_DATA(testActiveOpacityDontAffect)
 
 void TestXdgShellClientRules::testActiveOpacityDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityactive", 90);
     group.writeEntry("opacityactiverule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // The opacity should not be affected by the rule.
     QCOMPARE(client->opacity(), 1.0);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testActiveOpacityForce)
 
 void TestXdgShellClientRules::testActiveOpacityForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityactive", 90);
     group.writeEntry("opacityactiverule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 0.9);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testActiveOpacityForceTemporarily)
 
 void TestXdgShellClientRules::testActiveOpacityForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityactive", 90);
     group.writeEntry("opacityactiverule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 0.9);
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 1.0);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testInactiveOpacityDontAffect)
 
 void TestXdgShellClientRules::testInactiveOpacityDontAffect()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityinactive", 80);
     group.writeEntry("opacityinactiverule", int(Rules::DontAffect));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
 
     // Make the client inactive.
     workspace()->setActiveClient(nullptr);
     QVERIFY(!client->isActive());
 
     // The opacity of the client should not be affected by the rule.
     QCOMPARE(client->opacity(), 1.0);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testInactiveOpacityForce)
 
 void TestXdgShellClientRules::testInactiveOpacityForce()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityinactive", 80);
     group.writeEntry("opacityinactiverule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 1.0);
 
     // Make the client inactive.
     workspace()->setActiveClient(nullptr);
     QVERIFY(!client->isActive());
 
     // The opacity should be forced by the rule.
     QCOMPARE(client->opacity(), 0.8);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 TEST_DATA(testInactiveOpacityForceTemporarily)
 
 void TestXdgShellClientRules::testInactiveOpacityForceTemporarily()
 {
     // Initialize RuleBook with the test rule.
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
     KConfigGroup group = config->group("1");
     group.writeEntry("opacityinactive", 80);
     group.writeEntry("opacityinactiverule", int(Rules::ForceTemporarily));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     // Create the test client.
     QFETCH(Test::XdgShellSurfaceType, type);
-    XdgShellClient *client;
+    AbstractClient *client;
     Surface *surface;
     XdgShellSurface *shellSurface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 1.0);
 
     // Make the client inactive.
     workspace()->setActiveClient(nullptr);
     QVERIFY(!client->isActive());
 
     // The opacity should be forced by the rule.
     QCOMPARE(client->opacity(), 0.8);
 
     // The rule should be discarded when the client is closed.
     delete shellSurface;
     delete surface;
     std::tie(client, surface, shellSurface) = createWindow(type, "org.kde.foo");
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->opacity(), 1.0);
     workspace()->setActiveClient(nullptr);
     QVERIFY(!client->isActive());
     QCOMPARE(client->opacity(), 1.0);
 
     // Destroy the client.
     delete shellSurface;
     delete surface;
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClientRules::testMatchAfterNameChange()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     config->group("General").writeEntry("count", 1);
 
     KConfigGroup group = config->group("1");
     group.writeEntry("above", true);
     group.writeEntry("aboverule", int(Rules::Force));
     group.writeEntry("wmclass", "org.kde.foo");
     group.writeEntry("wmclasscomplete", false);
     group.writeEntry("wmclassmatch", int(Rules::ExactMatch));
     group.sync();
 
     RuleBook::self()->setConfig(config);
     workspace()->slotReconfigure();
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellV6Surface(surface.data()));
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(c->keepAbove(), false);
 
     QSignalSpy desktopFileNameSpy(c, &AbstractClient::desktopFileNameChanged);
     QVERIFY(desktopFileNameSpy.isValid());
 
     shellSurface->setAppId(QByteArrayLiteral("org.kde.foo"));
     QVERIFY(desktopFileNameSpy.wait());
     QCOMPARE(c->keepAbove(), true);
 }
 
 WAYLANDTEST_MAIN(TestXdgShellClientRules)
 #include "xdgshellclient_rules_test.moc"
diff --git a/autotests/integration/xdgshellclient_test.cpp b/autotests/integration/xdgshellclient_test.cpp
index 20886aa83..d8eb81187 100644
--- a/autotests/integration/xdgshellclient_test.cpp
+++ b/autotests/integration/xdgshellclient_test.cpp
@@ -1,1644 +1,1643 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "cursor.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 #include "effects.h"
 #include "deleted.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/output.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/appmenu.h>
 
 #include <KWayland/Server/clientconnection.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/xdgdecoration_interface.h>
 
 #include <QDBusConnection>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <csignal>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xdgshellclient-0");
 
 class TestXdgShellClient : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMapUnmapMap_data();
     void testMapUnmapMap();
     void testDesktopPresenceChanged();
     void testTransientPositionAfterRemap();
     void testWindowOutputs_data();
     void testWindowOutputs();
     void testMinimizeActiveWindow_data();
     void testMinimizeActiveWindow();
     void testFullscreen_data();
     void testFullscreen();
 
     void testFullscreenRestore_data();
     void testFullscreenRestore();
     void testUserCanSetFullscreen_data();
     void testUserCanSetFullscreen();
     void testUserSetFullscreen_data();
     void testUserSetFullscreen();
 
     void testMaximizedToFullscreen_data();
     void testMaximizedToFullscreen();
     void testWindowOpensLargerThanScreen_data();
     void testWindowOpensLargerThanScreen();
     void testHidden_data();
     void testHidden();
     void testDesktopFileName();
     void testCaptionSimplified();
     void testCaptionMultipleWindows();
     void testUnresponsiveWindow_data();
     void testUnresponsiveWindow();
     void testX11WindowId_data();
     void testX11WindowId();
     void testAppMenu();
     void testNoDecorationModeRequested_data();
     void testNoDecorationModeRequested();
     void testSendClientWithTransientToDesktop_data();
     void testSendClientWithTransientToDesktop();
     void testMinimizeWindowWithTransients_data();
     void testMinimizeWindowWithTransients();
     void testXdgDecoration_data();
     void testXdgDecoration();
     void testXdgNeverCommitted();
     void testXdgInitialState();
     void testXdgInitiallyMaximised();
     void testXdgInitiallyFullscreen();
     void testXdgInitiallyMinimized();
     void testXdgWindowGeometryIsntSet();
     void testXdgWindowGeometryAttachBuffer();
     void testXdgWindowGeometryAttachSubSurface();
     void testXdgWindowGeometryInteractiveResize();
     void testXdgWindowGeometryFullScreen();
     void testXdgWindowGeometryMaximize();
 };
 
 void TestXdgShellClient::initTestCase()
 {
     qRegisterMetaType<KWin::Deleted*>();
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWayland::Client::Output*>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestXdgShellClient::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration |
                                          Test::AdditionalWaylandInterface::XdgDecoration |
                                          Test::AdditionalWaylandInterface::AppMenu));
 
     screens()->setCurrent(0);
     KWin::Cursor::setPos(QPoint(1280, 512));
 }
 
 void TestXdgShellClient::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestXdgShellClient::testMapUnmapMap_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMapUnmapMap()
 {
     // this test verifies that mapping a previously mapped window works correctly
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     QSignalSpy effectsWindowShownSpy(effects, &EffectsHandler::windowShown);
     QVERIFY(effectsWindowShownSpy.isValid());
     QSignalSpy effectsWindowHiddenSpy(effects, &EffectsHandler::windowHidden);
     QVERIFY(effectsWindowHiddenSpy.isValid());
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     // now let's render
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(clientAddedSpy.isEmpty());
     QVERIFY(clientAddedSpy.wait());
-    auto client = clientAddedSpy.first().first().value<XdgShellClient *>();
+    auto client = clientAddedSpy.first().first().value<AbstractClient *>();
     QVERIFY(client);
     QVERIFY(client->isShown(true));
     QCOMPARE(client->isHiddenInternal(), false);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->depth(), 32);
     QVERIFY(client->hasAlpha());
     QCOMPARE(client->icon().name(), QStringLiteral("wayland"));
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(effectsWindowShownSpy.isEmpty());
     QVERIFY(client->isMaximizable());
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QVERIFY(client->isResizable());
     QVERIFY(client->property("maximizable").toBool());
     QVERIFY(client->property("moveable").toBool());
     QVERIFY(client->property("moveableAcrossScreens").toBool());
     QVERIFY(client->property("resizeable").toBool());
     QCOMPARE(client->isInternal(), false);
     QVERIFY(client->effectWindow());
     QVERIFY(!client->effectWindow()->internalWindow());
     QCOMPARE(client->internalId().isNull(), false);
     const auto uuid = client->internalId();
     QUuid deletedUuid;
     QCOMPARE(deletedUuid.isNull(), true);
 
-    connect(client, &XdgShellClient::windowClosed, this, [&deletedUuid] (Toplevel *, Deleted *d) { deletedUuid = d->internalId(); });
+    connect(client, &AbstractClient::windowClosed, this, [&deletedUuid] (Toplevel *, Deleted *d) { deletedUuid = d->internalId(); });
 
     // now unmap
-    QSignalSpy hiddenSpy(client, &XdgShellClient::windowHidden);
+    QSignalSpy hiddenSpy(client, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
-    QSignalSpy windowClosedSpy(client, &XdgShellClient::windowClosed);
+    QSignalSpy windowClosedSpy(client, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), true);
     QVERIFY(windowClosedSpy.isEmpty());
     QVERIFY(!workspace()->activeClient());
     QCOMPARE(effectsWindowHiddenSpy.count(), 1);
     QCOMPARE(effectsWindowHiddenSpy.first().first().value<EffectWindow*>(), client->effectWindow());
 
-    QSignalSpy windowShownSpy(client, &XdgShellClient::windowShown);
+    QSignalSpy windowShownSpy(client, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue, QImage::Format_RGB32);
     QCOMPARE(clientAddedSpy.count(), 1);
     QVERIFY(windowShownSpy.wait());
     QCOMPARE(windowShownSpy.count(), 1);
     QCOMPARE(clientAddedSpy.count(), 1);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), false);
     QCOMPARE(client->depth(), 24);
     QVERIFY(!client->hasAlpha());
     QCOMPARE(workspace()->activeClient(), client);
     QCOMPARE(effectsWindowShownSpy.count(), 1);
     QCOMPARE(effectsWindowShownSpy.first().first().value<EffectWindow*>(), client->effectWindow());
 
     // let's unmap again
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(hiddenSpy.count(), 2);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), true);
     QCOMPARE(client->internalId(), uuid);
     QVERIFY(windowClosedSpy.isEmpty());
     QCOMPARE(effectsWindowHiddenSpy.count(), 2);
     QCOMPARE(effectsWindowHiddenSpy.last().first().value<EffectWindow*>(), client->effectWindow());
 
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
     QCOMPARE(windowClosedSpy.count(), 1);
     QCOMPARE(effectsWindowHiddenSpy.count(), 2);
     QCOMPARE(deletedUuid.isNull(), false);
     QCOMPARE(deletedUuid, uuid);
 }
 
 void TestXdgShellClient::testDesktopPresenceChanged()
 {
     // this test verifies that the desktop presence changed signals are properly emitted
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->desktop(), 1);
     effects->setNumberOfDesktops(4);
-    QSignalSpy desktopPresenceChangedClientSpy(c, &XdgShellClient::desktopPresenceChanged);
+    QSignalSpy desktopPresenceChangedClientSpy(c, &AbstractClient::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedClientSpy.isValid());
     QSignalSpy desktopPresenceChangedWorkspaceSpy(workspace(), &Workspace::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedWorkspaceSpy.isValid());
     QSignalSpy desktopPresenceChangedEffectsSpy(effects, &EffectsHandler::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedEffectsSpy.isValid());
 
     // let's change the desktop
     workspace()->sendClientToDesktop(c, 2, false);
     QCOMPARE(c->desktop(), 2);
     QCOMPARE(desktopPresenceChangedClientSpy.count(), 1);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.count(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.count(), 1);
 
     // verify the arguments
     QCOMPARE(desktopPresenceChangedClientSpy.first().at(0).value<AbstractClient*>(), c);
     QCOMPARE(desktopPresenceChangedClientSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(0).value<AbstractClient*>(), c);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(0).value<EffectWindow*>(), c->effectWindow());
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(2).toInt(), 2);
 }
 
 void TestXdgShellClient::testTransientPositionAfterRemap()
 {
     // this test simulates the situation that a transient window gets reused and the parent window
     // moved between the two usages
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // create the Transient window
     XdgPositioner positioner(QSize(50, 40), QRect(0, 0, 5, 10));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QScopedPointer<Surface> transientSurface(Test::createSurface());
     QScopedPointer<XdgShellPopup> transientShellSurface(Test::createXdgShellStablePopup(transientSurface.data(), shellSurface.data(), positioner));
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), positioner.initialSize(), Qt::blue);
     QVERIFY(transient);
     QCOMPARE(transient->frameGeometry(), QRect(c->frameGeometry().topLeft() + QPoint(5, 10), QSize(50, 40)));
 
     // unmap the transient
-    QSignalSpy windowHiddenSpy(transient, &XdgShellClient::windowHidden);
+    QSignalSpy windowHiddenSpy(transient, &AbstractClient::windowHidden);
     QVERIFY(windowHiddenSpy.isValid());
     transientSurface->attachBuffer(Buffer::Ptr());
     transientSurface->commit(Surface::CommitFlag::None);
     QVERIFY(windowHiddenSpy.wait());
 
     // now move the parent surface
     c->setFrameGeometry(c->frameGeometry().translated(5, 10));
 
     // now map the transient again
-    QSignalSpy windowShownSpy(transient, &XdgShellClient::windowShown);
+    QSignalSpy windowShownSpy(transient, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(transientSurface.data(), QSize(50, 40), Qt::blue);
     QVERIFY(windowShownSpy.wait());
     QCOMPARE(transient->frameGeometry(), QRect(c->frameGeometry().topLeft() + QPoint(5, 10), QSize(50, 40)));
 }
 
 void TestXdgShellClient::testWindowOutputs_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testWindowOutputs()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto size = QSize(200,200);
 
     QSignalSpy outputEnteredSpy(surface.data(), &Surface::outputEntered);
     QSignalSpy outputLeftSpy(surface.data(), &Surface::outputLeft);
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     //move to be in the first screen
     c->setFrameGeometry(QRect(QPoint(100,100), size));
     //we don't don't know where the compositor first placed this window,
     //this might fire, it might not
     outputEnteredSpy.wait(5);
     outputEnteredSpy.clear();
 
     QCOMPARE(surface->outputs().count(), 1);
     QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(0,0));
 
     //move to overlapping both first and second screen
     c->setFrameGeometry(QRect(QPoint(1250,100), size));
     QVERIFY(outputEnteredSpy.wait());
     QCOMPARE(outputEnteredSpy.count(), 1);
     QCOMPARE(outputLeftSpy.count(), 0);
     QCOMPARE(surface->outputs().count(), 2);
     QVERIFY(surface->outputs()[0] != surface->outputs()[1]);
 
     //move entirely into second screen
     c->setFrameGeometry(QRect(QPoint(1400,100), size));
     QVERIFY(outputLeftSpy.wait());
     QCOMPARE(outputEnteredSpy.count(), 1);
     QCOMPARE(outputLeftSpy.count(), 1);
     QCOMPARE(surface->outputs().count(), 1);
     QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(1280,0));
 }
 
 void TestXdgShellClient::testMinimizeActiveWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMinimizeActiveWindow()
 {
     // this test verifies that when minimizing the active window it gets deactivated
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<QObject> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
 
     workspace()->slotWindowMinimize();
     QVERIFY(!c->isShown(true));
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(!c->isActive());
     QVERIFY(!workspace()->activeClient());
     QVERIFY(c->isMinimized());
 
     // unminimize again
     c->unminimize();
     QVERIFY(!c->isMinimized());
     QVERIFY(c->isActive());
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
     QCOMPARE(workspace()->activeClient(), c);
 }
 
 void TestXdgShellClient::testFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << ServerSideDecoration::Mode::Client;
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Client;
 
     QTest::newRow("xdgShellV6 - deco") << Test::XdgShellSurfaceType::XdgShellV6 << ServerSideDecoration::Mode::Server;
     QTest::newRow("xdgShellWmBase - deco") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Server;
 }
 
 void TestXdgShellClient::testFullscreen()
 {
     // this test verifies that a window can be properly fullscreened
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(shellSurface);
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     QFETCH(ServerSideDecoration::Mode, decoMode);
     deco->requestMode(decoMode);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), decoMode);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(c->layer(), NormalLayer);
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
     QCOMPARE(c->clientSizeToFrameSize(c->clientSize()), c->frameGeometry().size());
-    QSignalSpy fullscreenChangedSpy(c, &XdgShellClient::fullScreenChanged);
+    QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
-    QSignalSpy frameGeometryChangedSpy(c, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
 
     shellSurface->setFullscreen(true);
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
     QCOMPARE(sizeChangeRequestedSpy.first().first().toSize(), QSize(screens()->size(0)));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QVERIFY(frameGeometryChangedSpy.isEmpty());
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.first().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QVERIFY(c->isFullScreen());
     QVERIFY(!c->isDecorated());
     QCOMPARE(c->frameGeometry(), QRect(QPoint(0, 0), sizeChangeRequestedSpy.first().first().toSize()));
     QCOMPARE(c->layer(), ActiveLayer);
 
     // swap back to normal
     shellSurface->setFullscreen(false);
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 2);
     QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(100, 50));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->layer(), NormalLayer);
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
 }
 
 void TestXdgShellClient::testFullscreenRestore_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testFullscreenRestore()
 {
     // this test verifies that windows created fullscreen can be later properly restored
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     XdgShellSurface *xdgShellSurface = Test::createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly);
     QSignalSpy configureRequestedSpy(xdgShellSurface, &XdgShellSurface::configureRequested);
 
     // fullscreen the window
     xdgShellSurface->setFullscreen(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, screens()->size(0));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
     xdgShellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isFullScreen());
 
     configureRequestedSpy.wait(100);
 
-    QSignalSpy fullscreenChangedSpy(c, &XdgShellClient::fullScreenChanged);
+    QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
-    QSignalSpy frameGeometryChangedSpy(c, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     // swap back to normal
     configureRequestedSpy.clear();
     xdgShellSurface->setFullscreen(false);
 
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.last().first().toSize(), QSize(0, 0));
     QVERIFY(!c->isFullScreen());
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toUInt());
     }
 
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->frameGeometry().size(), QSize(100, 50));
 }
 
 void TestXdgShellClient::testUserCanSetFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testUserCanSetFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
     QVERIFY(c->userCanSetFullScreen());
 }
 
 void TestXdgShellClient::testUserSetFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testUserSetFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(
         type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QVERIFY(!shellSurface.isNull());
 
     // wait for the initial configure event
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
 
     // The client gets activated, which gets another configure event. Though that's not relevant to the test
     configureRequestedSpy.wait(10);
 
     QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
     c->setFullScreen(true);
     QCOMPARE(c->isFullScreen(), true);
     configureRequestedSpy.clear();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first().at(0).toSize(), screens()->size(0));
     const auto states = configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>();
     QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
     QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Maximized));
     QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Resizing));
     QCOMPARE(fullscreenChangedSpy.count(), 1);
     QVERIFY(c->isFullScreen());
 
     shellSurface->ackConfigure(configureRequestedSpy.first().at(2).value<quint32>());
 
     // unset fullscreen again
     c->setFullScreen(false);
     QCOMPARE(c->isFullScreen(), false);
     configureRequestedSpy.clear();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first().at(0).toSize(), QSize(100, 50));
     QVERIFY(!configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>().testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
     QCOMPARE(fullscreenChangedSpy.count(), 2);
     QVERIFY(!c->isFullScreen());
 }
 
 void TestXdgShellClient::testMaximizedToFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6 << ServerSideDecoration::Mode::Client;
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Client;
 
     QTest::newRow("xdgShellV6 - deco") << Test::XdgShellSurfaceType::XdgShellV6 << ServerSideDecoration::Mode::Server;
     QTest::newRow("xdgShellWmBase - deco") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Server;
 }
 
 void TestXdgShellClient::testMaximizedToFullscreen()
 {
     // this test verifies that a window can be properly fullscreened after maximizing
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(shellSurface);
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     QFETCH(ServerSideDecoration::Mode, decoMode);
     deco->requestMode(decoMode);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), decoMode);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
-    QSignalSpy fullscreenChangedSpy(c, &XdgShellClient::fullScreenChanged);
+    QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
-    QSignalSpy frameGeometryChangedSpy(c, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     shellSurface->setMaximized(true);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     QCOMPARE(c->maximizeMode(), MaximizeFull);
     QCOMPARE(frameGeometryChangedSpy.isEmpty(), false);
     frameGeometryChangedSpy.clear();
 
     // fullscreen the window
     shellSurface->setFullscreen(true);
     QVERIFY(fullscreenChangedSpy.wait());
     if (decoMode == ServerSideDecoration::Mode::Server) {
         QVERIFY(sizeChangeRequestedSpy.wait());
         QCOMPARE(sizeChangeRequestedSpy.count(), 2);
     }
     QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(screens()->size(0)));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(c->isFullScreen());
 
     // render at the new size
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
 
     QVERIFY(c->isFullScreen());
     QVERIFY(!c->isDecorated());
     QCOMPARE(c->frameGeometry(), QRect(QPoint(0, 0), sizeChangeRequestedSpy.last().first().toSize()));
     sizeChangeRequestedSpy.clear();
 
     // swap back to normal
     shellSurface->setFullscreen(false);
     shellSurface->setMaximized(false);
     QVERIFY(fullscreenChangedSpy.wait());
     if (decoMode == ServerSideDecoration::Mode::Server) {
          QVERIFY(sizeChangeRequestedSpy.wait());
          // XDG will legitimately get two updates. They might be batched
          if (shellSurface && sizeChangeRequestedSpy.count() == 1) {
              QVERIFY(sizeChangeRequestedSpy.wait());
          }
          QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(100, 50));
     }
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
 }
 
 void TestXdgShellClient::testWindowOpensLargerThanScreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testWindowOpensLargerThanScreen()
 {
     // this test creates a window which is as large as the screen, but is decorated
     // the window should get resized to fit into the screen, BUG: 366632
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), SIGNAL(sizeChanged(QSize)));
     QVERIFY(sizeChangeRequestedSpy.isValid());
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
 
     auto c = Test::renderAndWaitForShown(surface.data(), screens()->size(0), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(c->clientSize(), screens()->size(0));
     QVERIFY(c->isDecorated());
     QEXPECT_FAIL("", "BUG 366632", Continue);
     QVERIFY(sizeChangeRequestedSpy.wait(10));
 }
 
 void TestXdgShellClient::testHidden_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testHidden()
 {
     // this test verifies that when hiding window it doesn't get shown
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<QObject> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
 
     c->hideClient(true);
     QVERIFY(!c->isShown(true));
     QVERIFY(!c->isActive());
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
 
     // unhide again
     c->hideClient(false);
     QVERIFY(c->isShown(true));
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
 
     //QCOMPARE(workspace()->activeClient(), c);
 }
 
 void TestXdgShellClient::testDesktopFileName()
 {
     QIcon::setThemeName(QStringLiteral("breeze"));
     // this test verifies that desktop file name is passed correctly to the window
     QScopedPointer<Surface> surface(Test::createSurface());
     // only xdg-shell as ShellSurface misses the setter
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     shellSurface->setAppId(QByteArrayLiteral("org.kde.foo"));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.foo"));
     QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.foo"));
     QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
     // the desktop file does not exist, so icon should be generic Wayland
     QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
 
     QSignalSpy desktopFileNameChangedSpy(c, &AbstractClient::desktopFileNameChanged);
     QVERIFY(desktopFileNameChangedSpy.isValid());
-    QSignalSpy iconChangedSpy(c, &XdgShellClient::iconChanged);
+    QSignalSpy iconChangedSpy(c, &AbstractClient::iconChanged);
     QVERIFY(iconChangedSpy.isValid());
     shellSurface->setAppId(QByteArrayLiteral("org.kde.bar"));
     QVERIFY(desktopFileNameChangedSpy.wait());
     QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.bar"));
     QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.bar"));
     QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
     // icon should still be wayland
     QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
     QVERIFY(iconChangedSpy.isEmpty());
 
     const QString dfPath = QFINDTESTDATA("data/example.desktop");
     shellSurface->setAppId(dfPath.toUtf8());
     QVERIFY(desktopFileNameChangedSpy.wait());
     QCOMPARE(iconChangedSpy.count(), 1);
     QCOMPARE(QString::fromUtf8(c->desktopFileName()), dfPath);
     QCOMPARE(c->icon().name(), QStringLiteral("kwin"));
 }
 
 void TestXdgShellClient::testCaptionSimplified()
 {
     // this test verifies that caption is properly trimmed
     // see BUG 323798 comment #12
     QScopedPointer<Surface> surface(Test::createSurface());
     // only done for xdg-shell as ShellSurface misses the setter
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     const QString origTitle = QString::fromUtf8(QByteArrayLiteral("Was tun, wenn Schüler Autismus haben?\342\200\250\342\200\250\342\200\250 – Marlies Hübner - Mozilla Firefox"));
     shellSurface->setTitle(origTitle);
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->caption() != origTitle);
     QCOMPARE(c->caption(), origTitle.simplified());
 }
 
 void TestXdgShellClient::testCaptionMultipleWindows()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     shellSurface->setTitle(QStringLiteral("foo"));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->caption(), QStringLiteral("foo"));
     QCOMPARE(c->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c->captionSuffix(), QString());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     shellSurface2->setTitle(QStringLiteral("foo"));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c2);
     QCOMPARE(c2->caption(), QStringLiteral("foo <2>"));
     QCOMPARE(c2->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c2->captionSuffix(), QStringLiteral(" <2>"));
 
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     shellSurface3->setTitle(QStringLiteral("foo"));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c3);
     QCOMPARE(c3->caption(), QStringLiteral("foo <3>"));
     QCOMPARE(c3->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c3->captionSuffix(), QStringLiteral(" <3>"));
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
     shellSurface4->setTitle(QStringLiteral("bar"));
     auto c4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c4);
     QCOMPARE(c4->caption(), QStringLiteral("bar"));
     QCOMPARE(c4->captionNormal(), QStringLiteral("bar"));
     QCOMPARE(c4->captionSuffix(), QString());
-    QSignalSpy captionChangedSpy(c4, &XdgShellClient::captionChanged);
+    QSignalSpy captionChangedSpy(c4, &AbstractClient::captionChanged);
     QVERIFY(captionChangedSpy.isValid());
     shellSurface4->setTitle(QStringLiteral("foo"));
     QVERIFY(captionChangedSpy.wait());
     QCOMPARE(captionChangedSpy.count(), 1);
     QCOMPARE(c4->caption(), QStringLiteral("foo <4>"));
     QCOMPARE(c4->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c4->captionSuffix(), QStringLiteral(" <4>"));
 }
 
 void TestXdgShellClient::testUnresponsiveWindow_data()
 {
     QTest::addColumn<QString>("shellInterface");//see env selection in qwaylandintegration.cpp
     QTest::addColumn<bool>("socketMode");
 
     QTest::newRow("xdgv6 display") << "xdg-shell-v6" << false;
     QTest::newRow("xdgv6 socket") << "xdg-shell-v6" << true;
 
     //TODO add XDG WM Base when Kwin relies on Qt 5.12
 }
 
 void TestXdgShellClient::testUnresponsiveWindow()
 {
     // this test verifies that killWindow properly terminates a process
     // for this an external binary is launched
     const QString kill = QFINDTESTDATA(QStringLiteral("kill"));
     QVERIFY(!kill.isEmpty());
     QSignalSpy shellClientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(shellClientAddedSpy.isValid());
 
     QScopedPointer<QProcess> process(new QProcess);
     QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
 
     QFETCH(QString, shellInterface);
     QFETCH(bool, socketMode);
     env.insert("QT_WAYLAND_SHELL_INTEGRATION", shellInterface);
     if (socketMode) {
         int sx[2];
         QVERIFY(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) >= 0);
         waylandServer()->display()->createClient(sx[0]);
         int socket = dup(sx[1]);
         QVERIFY(socket != -1);
         env.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
         env.remove("WAYLAND_DISPLAY");
     } else {
         env.insert("WAYLAND_DISPLAY", s_socketName);
     }
     process->setProcessEnvironment(env);
     process->setProcessChannelMode(QProcess::ForwardedChannels);
     process->setProgram(kill);
     QSignalSpy processStartedSpy{process.data(), &QProcess::started};
     QVERIFY(processStartedSpy.isValid());
     process->start();
     QVERIFY(processStartedSpy.wait());
 
     AbstractClient *killClient = nullptr;
     if (shellClientAddedSpy.isEmpty()) {
         QVERIFY(shellClientAddedSpy.wait());
     }
     ::kill(process->processId(), SIGUSR1); // send a signal to freeze the process
 
     killClient = shellClientAddedSpy.first().first().value<AbstractClient*>();
     QVERIFY(killClient);
     QSignalSpy unresponsiveSpy(killClient, &AbstractClient::unresponsiveChanged);
     QSignalSpy killedSpy(process.data(), static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished));
     QSignalSpy deletedSpy(killClient, &QObject::destroyed);
 
     qint64 startTime = QDateTime::currentMSecsSinceEpoch();
 
     //wait for the process to be frozen
     QTest::qWait(10);
 
     //pretend the user clicked the close button
     killClient->closeWindow();
 
     //client should not yet be marked unresponsive nor killed
     QVERIFY(!killClient->unresponsive());
     QVERIFY(killedSpy.isEmpty());
 
     QVERIFY(unresponsiveSpy.wait());
     //client should be marked unresponsive but not killed
     auto elapsed1 = QDateTime::currentMSecsSinceEpoch() - startTime;
     QVERIFY(elapsed1 > 900  && elapsed1 < 1200); //ping timer is 1s, but coarse timers on a test across two processes means we need a fuzzy compare
     QVERIFY(killClient->unresponsive());
     QVERIFY(killedSpy.isEmpty());
 
     QVERIFY(deletedSpy.wait());
     if (!socketMode) {
         //process was killed - because we're across process this could happen in either order
         QVERIFY(killedSpy.count() || killedSpy.wait());
     }
 
     auto elapsed2 = QDateTime::currentMSecsSinceEpoch() - startTime;
     QVERIFY(elapsed2 > 1800); //second ping comes in a second later
 }
 
 void TestXdgShellClient::testX11WindowId_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testX11WindowId()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->windowId() != 0);
     QCOMPARE(c->window(), 0u);
 }
 
 void TestXdgShellClient::testAppMenu()
 {
     //register a faux appmenu client
     QVERIFY (QDBusConnection::sessionBus().registerService("org.kde.kappmenu"));
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QScopedPointer<AppMenu> menu(Test::waylandAppMenuManager()->create(surface.data()));
-    QSignalSpy spy(c, &XdgShellClient::hasApplicationMenuChanged);
+    QSignalSpy spy(c, &AbstractClient::hasApplicationMenuChanged);
     menu->setAddress("service.name", "object/path");
     spy.wait();
     QCOMPARE(c->hasApplicationMenu(), true);
     QCOMPARE(c->applicationMenuServiceName(), QString("service.name"));
     QCOMPARE(c->applicationMenuObjectPath(), QString("object/path"));
 
     QVERIFY (QDBusConnection::sessionBus().unregisterService("org.kde.kappmenu"));
 }
 
 void TestXdgShellClient::testNoDecorationModeRequested_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testNoDecorationModeRequested()
 {
     // this test verifies that the decoration follows the default mode if no mode is explicitly requested
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     if (deco->mode() != ServerSideDecoration::Mode::Server) {
         QVERIFY(decoSpy.wait());
     }
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->noBorder(), false);
     QCOMPARE(c->isDecorated(), true);
 }
 
 void TestXdgShellClient::testSendClientWithTransientToDesktop_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testSendClientWithTransientToDesktop()
 {
     // this test verifies that when sending a client to a desktop all transients are also send to that desktop
 
     VirtualDesktopManager::self()->setCount(2);
     QScopedPointer<Surface> surface{Test::createSurface()};
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // let's create a transient window
     QScopedPointer<Surface> transientSurface{Test::createSurface()};
     QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellSurface(type, transientSurface.data()));
     transientShellSurface->setTransientFor(shellSurface.data());
 
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(transient);
     QCOMPARE(workspace()->activeClient(), transient);
     QCOMPARE(transient->transientFor(), c);
     QVERIFY(c->transients().contains(transient));
 
     QCOMPARE(c->desktop(), 1);
     QVERIFY(!c->isOnAllDesktops());
     QCOMPARE(transient->desktop(), 1);
     QVERIFY(!transient->isOnAllDesktops());
     workspace()->slotWindowToDesktop(2);
 
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 2);
 
     // activate c
     workspace()->activateClient(c);
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->isActive());
 
     // and send it to the desktop it's already on
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 2);
     workspace()->slotWindowToDesktop(1);
 
     // which should move the transient back to the desktop
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 1);
 }
 
 void TestXdgShellClient::testMinimizeWindowWithTransients_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellV6") << Test::XdgShellSurfaceType::XdgShellV6;
     QTest::newRow("xdgWmBase")  << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMinimizeWindowWithTransients()
 {
     // this test verifies that when minimizing/unminimizing a window all its
     // transients will be minimized/unminimized as well
 
     // create the main window
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->isMinimized());
 
     // create a transient window
     QScopedPointer<Surface> transientSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellSurface(type, transientSurface.data()));
     transientShellSurface->setTransientFor(shellSurface.data());
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::red);
     QVERIFY(transient);
     QVERIFY(!transient->isMinimized());
     QCOMPARE(transient->transientFor(), c);
     QVERIFY(c->hasTransient(transient, false));
 
     // minimize the main window, the transient should be minimized as well
     c->minimize();
     QVERIFY(c->isMinimized());
     QVERIFY(transient->isMinimized());
 
     // unminimize the main window, the transient should be unminimized as well
     c->unminimize();
     QVERIFY(!c->isMinimized());
     QVERIFY(!transient->isMinimized());
 }
 
 void TestXdgShellClient::testXdgDecoration_data()
 {
     QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("requestedMode");
     QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("expectedMode");
 
     QTest::newRow("client side requested") << XdgDecoration::Mode::ClientSide << XdgDecoration::Mode::ClientSide;
     QTest::newRow("server side requested") << XdgDecoration::Mode::ServerSide << XdgDecoration::Mode::ServerSide;
 }
 
 void TestXdgShellClient::testXdgDecoration()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
 
     QSignalSpy decorationConfiguredSpy(deco.data(), &XdgDecoration::modeChanged);
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     QFETCH(KWayland::Client::XdgDecoration::Mode, requestedMode);
     QFETCH(KWayland::Client::XdgDecoration::Mode, expectedMode);
 
     //request a mode
     deco->setMode(requestedMode);
 
     //kwin will send a configure
     decorationConfiguredSpy.wait();
     configureRequestedSpy.wait();
 
     QCOMPARE(decorationConfiguredSpy.count(), 1);
     QCOMPARE(decorationConfiguredSpy.first()[0].value<KWayland::Client::XdgDecoration::Mode>(), expectedMode);
     QVERIFY(configureRequestedSpy.count() > 0);
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QCOMPARE(c->userCanSetNoBorder(), expectedMode == XdgDecoration::Mode::ServerSide);
     QCOMPARE(c->isDecorated(), expectedMode == XdgDecoration::Mode::ServerSide);
 }
 
 void TestXdgShellClient::testXdgNeverCommitted()
 {
     //check we don't crash if we create a shell object but delete the XdgShellClient before committing it
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
 }
 
 void TestXdgShellClient::testXdgInitialState()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
 
     QCOMPARE(size, QSize(0, 0)); //client should chose it's preferred size
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(200,100), Qt::blue);
     QCOMPARE(c->size(), QSize(200, 100));
 }
 
 void TestXdgShellClient::testXdgInitiallyMaximised()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->setMaximized(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(1280, 1024));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Maximized);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QCOMPARE(c->maximizeMode(), MaximizeFull);
     QCOMPARE(c->size(), QSize(1280, 1024));
 }
 
 void TestXdgShellClient::testXdgInitiallyFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->setFullscreen(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(1280, 1024));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QCOMPARE(c->isFullScreen(), true);
     QCOMPARE(c->size(), QSize(1280, 1024));
 }
 
 void TestXdgShellClient::testXdgInitiallyMinimized()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->requestMinimize();
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(0, 0));
     QCOMPARE(state, 0);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     QEXPECT_FAIL("", "Client created in a minimised state is not exposed to kwin bug 404838", Abort);
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue, QImage::Format_ARGB32, 10);
     QVERIFY(c);
     QVERIFY(c->isMinimized());
 }
 
 void TestXdgShellClient::testXdgWindowGeometryIsntSet()
 {
     // This test verifies that the effective window geometry corresponds to the
     // bounding rectangle of the main surface and its sub-surfaces if no window
     // geometry is set by the client.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition);
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     QScopedPointer<Surface> childSurface(Test::createSurface());
     QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
     QVERIFY(subSurface);
     subSurface->setPosition(QPoint(-20, -10));
     Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(120, 60));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition + QPoint(20, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryAttachBuffer()
 {
     // This test verifies that the effective window geometry remains the same when
     // a new buffer is attached and xdg_surface.set_window_geometry is not called
     // again. Notice that the window geometry must remain the same even if the new
     // buffer is smaller.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 2);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     shellSurface->setWindowGeometry(QRect(5, 5, 90, 40));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 3);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(90, 40));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(5, 5));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryAttachSubSurface()
 {
     // This test verifies that the effective window geometry remains the same
     // when a new sub-surface is added and xdg_surface.set_window_geometry is
     // not called again.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
-    QSignalSpy frameGeometryChangedSpy(client, &XdgShellClient::frameGeometryChanged);
+    QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     QScopedPointer<Surface> childSurface(Test::createSurface());
     QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
     QVERIFY(subSurface);
     subSurface->setPosition(QPoint(-20, -20));
     Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
     surface->commit(Surface::CommitFlag::None);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     shellSurface->setWindowGeometry(QRect(-15, -15, 50, 40));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(50, 40));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(-15, -15));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryInteractiveResize()
 {
     // This test verifies that correct window geometry is provided along each
     // configure event when an xdg-shell is being interactively resized.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Start interactively resizing the client.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
 
     // Go right.
     QPoint cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(8, 0));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 80));
     shellSurface->setWindowGeometry(QRect(10, 10, 188, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(208, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->bufferGeometry().size(), QSize(208, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(188, 80));
 
     // Go down.
     cursorPos = KWin::Cursor::pos();
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursor::pos());
     QCOMPARE(KWin::Cursor::pos(), cursorPos + QPoint(0, 8));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 88));
     shellSurface->setWindowGeometry(QRect(10, 10, 188, 88));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(208, 108), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->bufferGeometry().size(), QSize(208, 108));
     QCOMPARE(client->frameGeometry().size(), QSize(188, 88));
 
     // Finish resizing the client.
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
 #if 0
     QEXPECT_FAIL("", "XdgShellClient currently doesn't send final configure event", Abort);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 5);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 #endif
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryFullScreen()
 {
     // This test verifies that an xdg-shell receives correct window geometry when
     // its fullscreen state gets changed.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Fullscreen));
     shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
     QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
 
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Fullscreen));
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(200, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryMaximize()
 {
     // This test verifies that an xdg-shell receives correct window geometry when
     // its maximized state gets changed.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
-    XdgShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
+    AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
     shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
     QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(200, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(TestXdgShellClient)
 #include "xdgshellclient_test.moc"
diff --git a/autotests/integration/xwayland_input_test.cpp b/autotests/integration/xwayland_input_test.cpp
index 8ae910868..bb8248e6e 100644
--- a/autotests/integration/xwayland_input_test.cpp
+++ b/autotests/integration/xwayland_input_test.cpp
@@ -1,315 +1,313 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 
 #include <KWayland/Server/seat_interface.h>
 
 #include <QSocketNotifier>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xwayland_input-0");
 
 class XWaylandInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testPointerEnterLeaveSsd();
     void testPointerEventLeaveCsd();
 };
 
 void XWaylandInputTest::initTestCase()
 {
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void XWaylandInputTest::init()
 {
     screens()->setCurrent(0);
     Cursor::setPos(QPoint(640, 512));
     xcb_warp_pointer(connection(), XCB_WINDOW_NONE, kwinApp()->x11RootWindow(), 0, 0, 0, 0, 640, 512);
     xcb_flush(connection());
     QVERIFY(waylandServer()->clients().isEmpty());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 class X11EventReaderHelper : public QObject
 {
     Q_OBJECT
 public:
     X11EventReaderHelper(xcb_connection_t *c);
 
 Q_SIGNALS:
     void entered(const QPoint &localPoint);
     void left(const QPoint &localPoint);
 
 private:
     void processXcbEvents();
     xcb_connection_t *m_connection;
     QSocketNotifier *m_notifier;
 };
 
 X11EventReaderHelper::X11EventReaderHelper(xcb_connection_t *c)
     : QObject()
     , m_connection(c)
     , m_notifier(new QSocketNotifier(xcb_get_file_descriptor(m_connection), QSocketNotifier::Read, this))
 {
     connect(m_notifier, &QSocketNotifier::activated, this, &X11EventReaderHelper::processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, &X11EventReaderHelper::processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::awake, this, &X11EventReaderHelper::processXcbEvents);
 }
 
 void X11EventReaderHelper::processXcbEvents()
 {
     while (auto event = xcb_poll_for_event(m_connection)) {
         const uint8_t eventType = event->response_type & ~0x80;
         switch (eventType) {
             case XCB_ENTER_NOTIFY: {
                 auto enterEvent = reinterpret_cast<xcb_enter_notify_event_t *>(event);
                 emit entered(QPoint(enterEvent->event_x, enterEvent->event_y));
                 break; }
             case XCB_LEAVE_NOTIFY: {
                 auto leaveEvent = reinterpret_cast<xcb_leave_notify_event_t *>(event);
                 emit left(QPoint(leaveEvent->event_x, leaveEvent->event_y));
                 break; }
         }
         free(event);
     }
     xcb_flush(m_connection);
 }
 
 void XWaylandInputTest::testPointerEnterLeaveSsd()
 {
     // this test simulates a pointer enter and pointer leave on a server-side decorated X11 window
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     if (xcb_get_setup(c.data())->release_number < 11800000) {
         QSKIP("XWayland 1.18 required");
     }
     X11EventReaderHelper eventReader(c.data());
     QSignalSpy enteredSpy(&eventReader, &X11EventReaderHelper::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(&eventReader, &X11EventReaderHelper::left);
     QVERIFY(leftSpy.isValid());
     // atom for the screenedge show hide functionality
     Xcb::Atom atom(QByteArrayLiteral("_KDE_NET_WM_SCREEN_EDGE_SHOW"), false, c.data());
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 100, 200);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
     QVERIFY(!client->readyForPainting());
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
 
     // move pointer into the window, should trigger an enter
     QVERIFY(!client->frameGeometry().contains(Cursor::pos()));
     QVERIFY(enteredSpy.isEmpty());
     Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), client->surface());
     QVERIFY(waylandServer()->seat()->focusedPointer());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.last().first(), client->frameGeometry().center() - client->clientPos());
 
     // move out of window
     Cursor::setPos(client->frameGeometry().bottomRight() + QPoint(10, 10));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.last().first(), client->frameGeometry().center() - client->clientPos());
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void XWaylandInputTest::testPointerEventLeaveCsd()
 {
     // this test simulates a pointer enter and pointer leave on a client-side decorated X11 window
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     if (xcb_get_setup(c.data())->release_number < 11800000) {
         QSKIP("XWayland 1.18 required");
     }
     if (!Xcb::Extensions::self()->isShapeAvailable()) {
         QSKIP("SHAPE extension is required");
     }
 
     X11EventReaderHelper eventReader(c.data());
     QSignalSpy enteredSpy(&eventReader, &X11EventReaderHelper::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(&eventReader, &X11EventReaderHelper::left);
     QVERIFY(leftSpy.isValid());
 
     // Extents of the client-side drop-shadow.
     NETStrut clientFrameExtent;
     clientFrameExtent.left = 10;
     clientFrameExtent.right = 10;
     clientFrameExtent.top = 5;
     clientFrameExtent.bottom = 20;
 
     // Need to set the bounding shape in order to create a window without decoration.
     xcb_rectangle_t boundingRect;
     boundingRect.x = 0;
     boundingRect.y = 0;
     boundingRect.width = 100 + clientFrameExtent.left + clientFrameExtent.right;
     boundingRect.height = 200 + clientFrameExtent.top + clientFrameExtent.bottom;
 
     xcb_window_t window = xcb_generate_id(c.data());
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, window, rootWindow(),
                       boundingRect.x, boundingRect.y, boundingRect.width, boundingRect.height,
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, boundingRect.x, boundingRect.y);
     xcb_icccm_size_hints_set_size(&hints, 1, boundingRect.width, boundingRect.height);
     xcb_icccm_set_wm_normal_hints(c.data(), window, &hints);
     xcb_shape_rectangles(c.data(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING,
                          XCB_CLIP_ORDERING_UNSORTED, window, 0, 0, 1, &boundingRect);
     NETWinInfo info(c.data(), window, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     info.setGtkFrameExtents(clientFrameExtent);
     xcb_map_window(c.data(), window);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
     QVERIFY(client->isClientSideDecorated());
     QCOMPARE(client->bufferGeometry(), QRect(0, 0, 120, 225));
     QCOMPARE(client->frameGeometry(), QRect(10, 5, 100, 200));
 
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
 
     // Move pointer into the window, should trigger an enter.
     QVERIFY(!client->frameGeometry().contains(Cursor::pos()));
     QVERIFY(enteredSpy.isEmpty());
     Cursor::setPos(client->frameGeometry().center());
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), client->surface());
     QVERIFY(waylandServer()->seat()->focusedPointer());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.last().first(), QPoint(59, 104));
 
     // Move out of the window, should trigger a leave.
     QVERIFY(leftSpy.isEmpty());
     Cursor::setPos(client->frameGeometry().bottomRight() + QPoint(100, 100));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.last().first(), QPoint(59, 104));
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), window);
     xcb_destroy_window(c.data(), window);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::XWaylandInputTest)
 #include "xwayland_input_test.moc"
diff --git a/autotests/integration/xwayland_selections_test.cpp b/autotests/integration/xwayland_selections_test.cpp
index ff20160e2..75867d896 100644
--- a/autotests/integration/xwayland_selections_test.cpp
+++ b/autotests/integration/xwayland_selections_test.cpp
@@ -1,197 +1,196 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 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 "kwin_wayland_test.h"
+#include "abstract_client.h"
 #include "platform.h"
-#include "xdgshellclient.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "../../xwl/databridge.h"
 
 #include <KWayland/Server/datadevice_interface.h>
 
 #include <QProcess>
 #include <QProcessEnvironment>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xwayland_selections-0");
 
 class XwaylandSelectionsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void testSync_data();
     void testSync();
 
 private:
     QProcess *m_copyProcess = nullptr;
     QProcess *m_pasteProcess = nullptr;
 };
 
 void XwaylandSelectionsTest::initTestCase()
 {
     QSKIP("Skipped as it fails for unknown reasons on build.kde.org");
-    qRegisterMetaType<KWin::XdgShellClient *>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<QProcess::ExitStatus>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
 //    QSignalSpy clipboardSyncDevicedCreated{waylandServer(), &WaylandServer::xclipboardSyncDataDeviceCreated};
 //    QVERIFY(clipboardSyncDevicedCreated.isValid());
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 //    // wait till the xclipboard sync data device is created
 //    if (clipboardSyncDevicedCreated.empty()) {
 //        QVERIFY(clipboardSyncDevicedCreated.wait());
 //    }
     // wait till the DataBridge sync data device is created
     while (Xwl::DataBridge::self()->dataDeviceIface() == nullptr) {
         QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
     }
     QVERIFY(Xwl::DataBridge::self()->dataDeviceIface() != nullptr);
 }
 
 void XwaylandSelectionsTest::cleanup()
 {
     if (m_copyProcess) {
         m_copyProcess->terminate();
         QVERIFY(m_copyProcess->waitForFinished());
         m_copyProcess = nullptr;
     }
     if (m_pasteProcess) {
         m_pasteProcess->terminate();
         QVERIFY(m_pasteProcess->waitForFinished());
         m_pasteProcess = nullptr;
     }
 }
 
 void XwaylandSelectionsTest::testSync_data()
 {
     QTest::addColumn<QString>("copyPlatform");
     QTest::addColumn<QString>("pastePlatform");
 
     QTest::newRow("x11->wayland") << QStringLiteral("xcb") << QStringLiteral("wayland");
     QTest::newRow("wayland->x11") << QStringLiteral("wayland") << QStringLiteral("xcb");
 }
 
 void XwaylandSelectionsTest::testSync()
 {
     // this test verifies the syncing of X11 to Wayland clipboard
     const QString copy = QFINDTESTDATA(QStringLiteral("copy"));
     QVERIFY(!copy.isEmpty());
     const QString paste = QFINDTESTDATA(QStringLiteral("paste"));
     QVERIFY(!paste.isEmpty());
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(clientAddedSpy.isValid());
     QSignalSpy shellClientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(shellClientAddedSpy.isValid());
     QSignalSpy clipboardChangedSpy(Xwl::DataBridge::self()->dataDeviceIface(), &KWayland::Server::DataDeviceInterface::selectionChanged);
     QVERIFY(clipboardChangedSpy.isValid());
 
     QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
 
     // start the copy process
     QFETCH(QString, copyPlatform);
     environment.insert(QStringLiteral("QT_QPA_PLATFORM"), copyPlatform);
     environment.insert(QStringLiteral("WAYLAND_DISPLAY"), s_socketName);
     m_copyProcess = new QProcess();
     m_copyProcess->setProcessEnvironment(environment);
     m_copyProcess->setProcessChannelMode(QProcess::ForwardedChannels);
     m_copyProcess->setProgram(copy);
     m_copyProcess->start();
     QVERIFY(m_copyProcess->waitForStarted());
 
     AbstractClient *copyClient = nullptr;
     if (copyPlatform == QLatin1String("xcb")) {
         QVERIFY(clientAddedSpy.wait());
         copyClient = clientAddedSpy.first().first().value<AbstractClient*>();
     } else {
         QVERIFY(shellClientAddedSpy.wait());
         copyClient = shellClientAddedSpy.first().first().value<AbstractClient*>();
     }
     QVERIFY(copyClient);
     if (workspace()->activeClient() != copyClient) {
         workspace()->activateClient(copyClient);
     }
     QCOMPARE(workspace()->activeClient(), copyClient);
     if (copyPlatform == QLatin1String("xcb")) {
         QVERIFY(clipboardChangedSpy.isEmpty());
         QVERIFY(clipboardChangedSpy.wait());
     } else {
         // TODO: it would be better to be able to connect to a signal, instead of waiting
         // the idea is to make sure that the clipboard is updated, thus we need to give it
         // enough time before starting the paste process which creates another window
         QTest::qWait(250);
     }
 
     // start the paste process
     m_pasteProcess = new QProcess();
     QSignalSpy finishedSpy(m_pasteProcess, static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished));
     QVERIFY(finishedSpy.isValid());
     QFETCH(QString, pastePlatform);
     environment.insert(QStringLiteral("QT_QPA_PLATFORM"), pastePlatform);
     m_pasteProcess->setProcessEnvironment(environment);
     m_pasteProcess->setProcessChannelMode(QProcess::ForwardedChannels);
     m_pasteProcess->setProgram(paste);
     m_pasteProcess->start();
     QVERIFY(m_pasteProcess->waitForStarted());
 
     AbstractClient *pasteClient = nullptr;
     if (pastePlatform == QLatin1String("xcb")) {
         QVERIFY(clientAddedSpy.wait());
         pasteClient = clientAddedSpy.last().first().value<AbstractClient*>();
     } else {
         QVERIFY(shellClientAddedSpy.wait());
         pasteClient = shellClientAddedSpy.last().first().value<AbstractClient*>();
     }
     QCOMPARE(clientAddedSpy.count(), 1);
     QCOMPARE(shellClientAddedSpy.count(), 1);
     QVERIFY(pasteClient);
 
     if (workspace()->activeClient() != pasteClient) {
         QSignalSpy clientActivatedSpy(workspace(), &Workspace::clientActivated);
         QVERIFY(clientActivatedSpy.isValid());
         workspace()->activateClient(pasteClient);
         QVERIFY(clientActivatedSpy.wait());
     }
     QTRY_COMPARE(workspace()->activeClient(), pasteClient);
     QVERIFY(finishedSpy.wait());
     QCOMPARE(finishedSpy.first().first().toInt(), 0);
     delete m_pasteProcess;
     m_pasteProcess = nullptr;
     delete m_copyProcess;
     m_copyProcess = nullptr;
 }
 
 WAYLANDTEST_MAIN(XwaylandSelectionsTest)
 #include "xwayland_selections_test.moc"
diff --git a/composite.cpp b/composite.cpp
index 0243688cd..fd15c57b9 100644
--- a/composite.cpp
+++ b/composite.cpp
@@ -1,1050 +1,1049 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "composite.h"
 
 #include "dbusinterface.h"
 #include "x11client.h"
 #include "decorations/decoratedclient.h"
 #include "deleted.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "overlaywindow.h"
 #include "platform.h"
 #include "scene.h"
 #include "screens.h"
 #include "shadow.h"
-#include "xdgshellclient.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "utils.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
 #include <kwingltexture.h>
 
 #include <KWayland/Server/surface_interface.h>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginLoader>
 #include <KPluginMetaData>
 #include <KNotification>
 #include <KSelectionOwner>
 
 #include <QDateTime>
 #include <QFutureWatcher>
 #include <QMenu>
 #include <QOpenGLContext>
 #include <QQuickWindow>
 #include <QtConcurrentRun>
 #include <QTextStream>
 #include <QTimerEvent>
 
 #include <xcb/composite.h>
 #include <xcb/damage.h>
 
 #include <cstdio>
 
 Q_DECLARE_METATYPE(KWin::X11Compositor::SuspendReason)
 
 namespace KWin
 {
 
 // See main.cpp:
 extern int screen_number;
 
 extern bool is_multihead;
 extern int currentRefreshRate();
 
 Compositor *Compositor::s_compositor = nullptr;
 Compositor *Compositor::self()
 {
     return s_compositor;
 }
 
 WaylandCompositor *WaylandCompositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new WaylandCompositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 X11Compositor *X11Compositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new X11Compositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 
 class CompositorSelectionOwner : public KSelectionOwner
 {
     Q_OBJECT
 public:
     CompositorSelectionOwner(const char *selection)
         : KSelectionOwner(selection, connection(), rootWindow())
         , m_owning(false)
     {
         connect (this, &CompositorSelectionOwner::lostOwnership,
                  this, [this]() { m_owning = false; });
     }
     bool owning() const {
         return m_owning;
     }
     void setOwning(bool own) {
         m_owning = own;
     }
 private:
     bool m_owning;
 };
 
 static inline qint64 milliToNano(int milli) { return qint64(milli) * 1000 * 1000; }
 static inline qint64 nanoToMilli(int nano) { return nano / (1000*1000); }
 
 Compositor::Compositor(QObject* workspace)
     : QObject(workspace)
     , m_state(State::Off)
     , m_selectionOwner(nullptr)
     , vBlankInterval(0)
     , fpsInterval(0)
     , m_timeSinceLastVBlank(0)
     , m_scene(nullptr)
     , m_bufferSwapPending(false)
     , m_composeAtSwapCompletion(false)
 {
     connect(options, &Options::configChanged, this, &Compositor::configChanged);
     connect(options, &Options::animationSpeedChanged, this, &Compositor::configChanged);
 
     m_monotonicClock.start();
 
     // 2 sec which should be enough to restart the compositor.
     static const int compositorLostMessageDelay = 2000;
 
     m_releaseSelectionTimer.setSingleShot(true);
     m_releaseSelectionTimer.setInterval(compositorLostMessageDelay);
     connect(&m_releaseSelectionTimer, &QTimer::timeout,
             this, &Compositor::releaseCompositorSelection);
 
     m_unusedSupportPropertyTimer.setInterval(compositorLostMessageDelay);
     m_unusedSupportPropertyTimer.setSingleShot(true);
     connect(&m_unusedSupportPropertyTimer, &QTimer::timeout,
             this, &Compositor::deleteUnusedSupportProperties);
 
     // Delay the call to start by one event cycle.
     // The ctor of this class is invoked from the Workspace ctor, that means before
     // Workspace is completely constructed, so calling Workspace::self() would result
     // in undefined behavior. This is fixed by using a delayed invocation.
     if (kwinApp()->platform()->isReady()) {
         QTimer::singleShot(0, this, &Compositor::start);
     }
     connect(kwinApp()->platform(), &Platform::readyChanged, this,
         [this] (bool ready) {
             if (ready) {
                 start();
             } else {
                 stop();
             }
         }, Qt::QueuedConnection
     );
 
     if (qEnvironmentVariableIsSet("KWIN_MAX_FRAMES_TESTED"))
        m_framesToTestForSafety = qEnvironmentVariableIntValue("KWIN_MAX_FRAMES_TESTED");
 
     // register DBus
     new CompositorDBusInterface(this);
 }
 
 Compositor::~Compositor()
 {
     emit aboutToDestroy();
     stop();
     deleteUnusedSupportProperties();
     destroyCompositorSelection();
     s_compositor = nullptr;
 }
 
 bool Compositor::setupStart()
 {
     if (kwinApp()->isTerminating()) {
         // Don't start while KWin is terminating. An event to restart might be lingering
         // in the event queue due to graphics reset.
         return false;
     }
     if (m_state != State::Off) {
         return false;
     }
     m_state = State::Starting;
 
     options->reloadCompositingSettings(true);
 
     setupX11Support();
 
     // There might still be a deleted around, needs to be cleared before
     // creating the scene (BUG 333275).
     if (Workspace::self()) {
         while (!Workspace::self()->deletedList().isEmpty()) {
             Workspace::self()->deletedList().first()->discard();
         }
     }
 
     emit aboutToToggleCompositing();
 
     auto supportedCompositors = kwinApp()->platform()->supportedCompositors();
     const auto userConfigIt = std::find(supportedCompositors.begin(), supportedCompositors.end(),
                                         options->compositingMode());
 
     if (userConfigIt != supportedCompositors.end()) {
         supportedCompositors.erase(userConfigIt);
         supportedCompositors.prepend(options->compositingMode());
     } else {
         qCWarning(KWIN_CORE)
                 << "Configured compositor not supported by Platform. Falling back to defaults";
     }
 
     const auto availablePlugins = KPluginLoader::findPlugins(QStringLiteral("org.kde.kwin.scenes"));
 
     for (auto type : qAsConst(supportedCompositors)) {
         const auto pluginIt = std::find_if(availablePlugins.begin(), availablePlugins.end(),
             [type] (const auto &plugin) {
                 const auto &metaData = plugin.rawData();
                 auto it = metaData.find(QStringLiteral("CompositingType"));
                 if (it != metaData.end()) {
                     if ((*it).toInt() == int{type}) {
                         return true;
                     }
                 }
                 return false;
             });
         if (pluginIt != availablePlugins.end()) {
             std::unique_ptr<SceneFactory>
                     factory{ qobject_cast<SceneFactory*>(pluginIt->instantiate()) };
             if (factory) {
                 m_scene = factory->create(this);
                 if (m_scene) {
                     if (!m_scene->initFailed()) {
                         qCDebug(KWIN_CORE) << "Instantiated compositing plugin:"
                                            << pluginIt->name();
                         break;
                     } else {
                         delete m_scene;
                         m_scene = nullptr;
                     }
                 }
             }
         }
     }
 
     if (m_scene == nullptr || m_scene->initFailed()) {
         qCCritical(KWIN_CORE) << "Failed to initialize compositing, compositing disabled";
         m_state = State::Off;
 
         delete m_scene;
         m_scene = nullptr;
 
         if (m_selectionOwner) {
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         if (!supportedCompositors.contains(NoCompositing)) {
             qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
             qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
             qApp->quit();
         }
         return false;
     }
 
     CompositingType compositingType = m_scene->compositingType();
     if (compositingType & OpenGLCompositing) {
         // Override for OpenGl sub-type OpenGL2Compositing.
         compositingType = OpenGLCompositing;
     }
     kwinApp()->platform()->setSelectedCompositor(compositingType);
 
     if (!Workspace::self() && m_scene && m_scene->compositingType() == QPainterCompositing) {
         // Force Software QtQuick on first startup with QPainter.
         QQuickWindow::setSceneGraphBackend(QSGRendererInterface::Software);
     }
 
     connect(m_scene, &Scene::resetCompositing, this, &Compositor::reinitialize);
     emit sceneCreated();
 
     return true;
 }
 
 void Compositor::claimCompositorSelection()
 {
     if (!m_selectionOwner) {
         char selection_name[ 100 ];
         sprintf(selection_name, "_NET_WM_CM_S%d", Application::x11ScreenNumber());
         m_selectionOwner = new CompositorSelectionOwner(selection_name);
         connect(m_selectionOwner, &CompositorSelectionOwner::lostOwnership,
                 this, &Compositor::stop);
     }
 
     if (!m_selectionOwner) {
         // No X11 yet.
         return;
     }
     if (!m_selectionOwner->owning()) {
         // Force claim ownership.
         m_selectionOwner->claim(true);
         m_selectionOwner->setOwning(true);
     }
 }
 
 void Compositor::setupX11Support()
 {
     auto *con = kwinApp()->x11Connection();
     if (!con) {
         delete m_selectionOwner;
         m_selectionOwner = nullptr;
         return;
     }
     claimCompositorSelection();
     xcb_composite_redirect_subwindows(con, kwinApp()->x11RootWindow(),
                                       XCB_COMPOSITE_REDIRECT_MANUAL);
 }
 
 void Compositor::startupWithWorkspace()
 {
     connect(kwinApp(), &Application::x11ConnectionChanged,
             this, &Compositor::setupX11Support, Qt::UniqueConnection);
     Workspace::self()->markXStackingOrderAsDirty();
     Q_ASSERT(m_scene);
 
     connect(workspace(), &Workspace::destroyed, this, [this] { compositeTimer.stop(); });
     setupX11Support();
     fpsInterval = options->maxFpsInterval();
 
     if (m_scene->syncsToVBlank()) {
         // If we do vsync, set the fps to the next multiple of the vblank rate.
         vBlankInterval = milliToNano(1000) / currentRefreshRate();
         fpsInterval = qMax((fpsInterval / vBlankInterval) * vBlankInterval, vBlankInterval);
     } else {
         // No vsync - DO NOT set "0", would cause div-by-zero segfaults.
         vBlankInterval = milliToNano(1);
     }
 
     // Sets also the 'effects' pointer.
     kwinApp()->platform()->createEffectsHandler(this, m_scene);
     connect(Workspace::self(), &Workspace::deletedRemoved, m_scene, &Scene::removeToplevel);
     connect(effects, &EffectsHandler::screenGeometryChanged, this, &Compositor::addRepaintFull);
 
     for (X11Client *c : Workspace::self()->clientList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (X11Client *c : Workspace::self()->desktopList()) {
         c->setupCompositing();
     }
     for (Unmanaged *c : Workspace::self()->unmanagedList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (InternalClient *client : workspace()->internalClients()) {
         client->setupCompositing();
         client->updateShadow();
     }
 
     if (auto *server = waylandServer()) {
         const auto clients = server->clients();
-        for (XdgShellClient *c : clients) {
+        for (AbstractClient *c : clients) {
             c->setupCompositing();
             c->updateShadow();
         }
     }
 
     m_state = State::On;
     emit compositingToggled(true);
 
     if (m_releaseSelectionTimer.isActive()) {
         m_releaseSelectionTimer.stop();
     }
 
     // Render at least once.
     addRepaintFull();
     performCompositing();
 }
 
 void Compositor::scheduleRepaint()
 {
     if (!compositeTimer.isActive())
         setCompositeTimer();
 }
 
 void Compositor::stop()
 {
     if (m_state == State::Off || m_state == State::Stopping) {
         return;
     }
     m_state = State::Stopping;
     emit aboutToToggleCompositing();
 
     m_releaseSelectionTimer.start();
 
     // Some effects might need access to effect windows when they are about to
     // be destroyed, for example to unreference deleted windows, so we have to
     // make sure that effect windows outlive effects.
     delete effects;
     effects = nullptr;
 
     if (Workspace::self()) {
         for (X11Client *c : Workspace::self()->clientList()) {
             m_scene->removeToplevel(c);
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             m_scene->removeToplevel(c);
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             m_scene->removeToplevel(c);
         }
         for (InternalClient *client : workspace()->internalClients()) {
             m_scene->removeToplevel(client);
         }
         for (X11Client *c : Workspace::self()->clientList()) {
             c->finishCompositing();
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             c->finishCompositing();
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             c->finishCompositing();
         }
         for (InternalClient *client : workspace()->internalClients()) {
             client->finishCompositing();
         }
         if (auto *con = kwinApp()->x11Connection()) {
             xcb_composite_unredirect_subwindows(con, kwinApp()->x11RootWindow(),
                                                 XCB_COMPOSITE_REDIRECT_MANUAL);
         }
         while (!workspace()->deletedList().isEmpty()) {
             workspace()->deletedList().first()->discard();
         }
     }
 
     if (waylandServer()) {
-        for (XdgShellClient *c : waylandServer()->clients()) {
+        for (AbstractClient *c : waylandServer()->clients()) {
             m_scene->removeToplevel(c);
         }
-        for (XdgShellClient *c : waylandServer()->clients()) {
+        for (AbstractClient *c : waylandServer()->clients()) {
             c->finishCompositing();
         }
     }
 
     delete m_scene;
     m_scene = nullptr;
     compositeTimer.stop();
     repaints_region = QRegion();
 
     m_state = State::Off;
     emit compositingToggled(false);
 }
 
 void Compositor::destroyCompositorSelection()
 {
     delete m_selectionOwner;
     m_selectionOwner = nullptr;
 }
 
 void Compositor::releaseCompositorSelection()
 {
     switch (m_state) {
     case State::On:
         // We are compositing at the moment. Don't release.
         break;
     case State::Off:
         if (m_selectionOwner) {
             qCDebug(KWIN_CORE) << "Releasing compositor selection";
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         break;
     case State::Starting:
     case State::Stopping:
         // Still starting or shutting down the compositor. Starting might fail
         // or after stopping a restart might follow. So test again later on.
         m_releaseSelectionTimer.start();
         break;
     }
 }
 
 void Compositor::keepSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties.removeAll(atom);
 }
 
 void Compositor::removeSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties << atom;
     m_unusedSupportPropertyTimer.start();
 }
 
 void Compositor::deleteUnusedSupportProperties()
 {
     if (m_state == State::Starting || m_state == State::Stopping) {
         // Currently still maybe restarting the compositor.
         m_unusedSupportPropertyTimer.start();
         return;
     }
     if (auto *con = kwinApp()->x11Connection()) {
         for (const xcb_atom_t &atom : qAsConst(m_unusedSupportProperties)) {
             // remove property from root window
             xcb_delete_property(con, kwinApp()->x11RootWindow(), atom);
         }
         m_unusedSupportProperties.clear();
     }
 }
 
 void Compositor::configChanged()
 {
     reinitialize();
     addRepaintFull();
 }
 
 void Compositor::reinitialize()
 {
     // Reparse config. Config options will be reloaded by start()
     kwinApp()->config()->reparseConfiguration();
 
     // Restart compositing
     stop();
     start();
 
     if (effects) { // start() may fail
         effects->reconfigure();
     }
 }
 
 void Compositor::addRepaint(int x, int y, int w, int h)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += QRegion(x, y, w, h);
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRect& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRegion& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaintFull()
 {
     if (m_state != State::On) {
         return;
     }
     const QSize &s = screens()->size();
     repaints_region = QRegion(0, 0, s.width(), s.height());
     scheduleRepaint();
 }
 
 void Compositor::timerEvent(QTimerEvent *te)
 {
     if (te->timerId() == compositeTimer.timerId()) {
         performCompositing();
     } else
         QObject::timerEvent(te);
 }
 
 void Compositor::aboutToSwapBuffers()
 {
     Q_ASSERT(!m_bufferSwapPending);
 
     m_bufferSwapPending = true;
 }
 
 void Compositor::bufferSwapComplete()
 {
     Q_ASSERT(m_bufferSwapPending);
     m_bufferSwapPending = false;
 
     emit bufferSwapCompleted();
 
     if (m_composeAtSwapCompletion) {
         m_composeAtSwapCompletion = false;
         performCompositing();
     }
 }
 
 void Compositor::performCompositing()
 {
     // If a buffer swap is still pending, we return to the event loop and
     // continue processing events until the swap has completed.
     if (m_bufferSwapPending) {
         m_composeAtSwapCompletion = true;
         compositeTimer.stop();
         return;
     }
 
     // If outputs are disabled, we return to the event loop and
     // continue processing events until the outputs are enabled again
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         compositeTimer.stop();
         return;
     }
 
     // Create a list of all windows in the stacking order
     QList<Toplevel *> windows = Workspace::self()->xStackingOrder();
     QList<Toplevel *> damaged;
 
     // Reset the damage state of each window and fetch the damage region
     // without waiting for a reply
     for (Toplevel *win : windows) {
         if (win->resetAndFetchDamage()) {
             damaged << win;
         }
     }
 
     if (damaged.count() > 0) {
         m_scene->triggerFence();
         if (auto c = kwinApp()->x11Connection()) {
             xcb_flush(c);
         }
     }
 
     // Move elevated windows to the top of the stacking order
     for (EffectWindow *c : static_cast<EffectsHandlerImpl *>(effects)->elevatedWindows()) {
         Toplevel *t = static_cast<EffectWindowImpl *>(c)->window();
         windows.removeAll(t);
         windows.append(t);
     }
 
     // Get the replies
     for (Toplevel *win : damaged) {
         // Discard the cached lanczos texture
         if (win->effectWindow()) {
             const QVariant texture = win->effectWindow()->data(LanczosCacheRole);
             if (texture.isValid()) {
                 delete static_cast<GLTexture *>(texture.value<void*>());
                 win->effectWindow()->setData(LanczosCacheRole, QVariant());
             }
         }
 
         win->getDamageRegionReply();
     }
 
     if (repaints_region.isEmpty() && !windowRepaintsPending()) {
         m_scene->idle();
         m_timeSinceLastVBlank = fpsInterval - (options->vBlankTime() + 1); // means "start now"
         // Note: It would seem here we should undo suspended unredirect, but when scenes need
         // it for some reason, e.g. transformations or translucency, the next pass that does not
         // need this anymore and paints normally will also reset the suspended unredirect.
         // Otherwise the window would not be painted normally anyway.
         compositeTimer.stop();
         return;
     }
 
     // Skip windows that are not yet ready for being painted and if screen is locked skip windows
     // that are neither lockscreen nor inputmethod windows.
     //
     // TODO? This cannot be used so carelessly - needs protections against broken clients, the
     // window should not get focus before it's displayed, handle unredirected windows properly and
     // so on.
     for (Toplevel *win : windows) {
         if (!win->readyForPainting()) {
             windows.removeAll(win);
         }
         if (waylandServer() && waylandServer()->isScreenLocked()) {
             if(!win->isLockScreen() && !win->isInputMethod()) {
                 windows.removeAll(win);
             }
         }
     }
 
     QRegion repaints = repaints_region;
     // clear all repaints, so that post-pass can add repaints for the next repaint
     repaints_region = QRegion();
 
     if (m_framesToTestForSafety > 0 && (m_scene->compositingType() & OpenGLCompositing)) {
         kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreFrame);
     }
     m_timeSinceLastVBlank = m_scene->paint(repaints, windows);
     if (m_framesToTestForSafety > 0) {
         if (m_scene->compositingType() & OpenGLCompositing) {
             kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostFrame);
         }
         m_framesToTestForSafety--;
         if (m_framesToTestForSafety == 0 && (m_scene->compositingType() & OpenGLCompositing)) {
             kwinApp()->platform()->createOpenGLSafePoint(
                 Platform::OpenGLSafePoint::PostLastGuardedFrame);
         }
     }
 
     if (waylandServer()) {
         const auto currentTime = static_cast<quint32>(m_monotonicClock.elapsed());
         for (Toplevel *win : qAsConst(windows)) {
             if (auto surface = win->surface()) {
                 surface->frameRendered(currentTime);
             }
         }
     }
 
     // Stop here to ensure *we* cause the next repaint schedule - not some effect
     // through m_scene->paint().
     compositeTimer.stop();
 
     // Trigger at least one more pass even if there would be nothing to paint, so that scene->idle()
     // is called the next time. If there would be nothing pending, it will not restart the timer and
     // scheduleRepaint() would restart it again somewhen later, called from functions that
     // would again add something pending.
     if (m_bufferSwapPending && m_scene->syncsToVBlank()) {
         m_composeAtSwapCompletion = true;
     } else {
         scheduleRepaint();
     }
 }
 
 template <class T>
 static bool repaintsPending(const QList<T*> &windows)
 {
     return std::any_of(windows.begin(), windows.end(),
                        [](T *t) { return !t->repaints().isEmpty(); });
 }
 
 bool Compositor::windowRepaintsPending() const
 {
     if (repaintsPending(Workspace::self()->clientList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->desktopList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->unmanagedList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->deletedList())) {
         return true;
     }
     if (auto *server = waylandServer()) {
         const auto &clients = server->clients();
-        auto test = [](XdgShellClient *c) {
+        auto test = [](AbstractClient *c) {
             return c->readyForPainting() && !c->repaints().isEmpty();
         };
         if (std::any_of(clients.begin(), clients.end(), test)) {
             return true;
         }
     }
     const auto &internalClients = workspace()->internalClients();
     auto internalTest = [] (InternalClient *client) {
         return client->isShown(true) && !client->repaints().isEmpty();
     };
     if (std::any_of(internalClients.begin(), internalClients.end(), internalTest)) {
         return true;
     }
     return false;
 }
 
 void Compositor::setCompositeTimer()
 {
     if (m_state != State::On) {
         return;
     }
 
     // Don't start the timer if we're waiting for a swap event
     if (m_bufferSwapPending && m_composeAtSwapCompletion)
         return;
 
     // Don't start the timer if all outputs are disabled
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         return;
     }
 
     uint waitTime = 1;
 
     if (m_scene->blocksForRetrace()) {
 
         // TODO: make vBlankTime dynamic?!
         // It's required because glXWaitVideoSync will *likely* block a full frame if one enters
         // a retrace pass which can last a variable amount of time, depending on the actual screen
         // Now, my ooold 19" CRT can do such retrace so that 2ms are entirely sufficient,
         // while another ooold 15" TFT requires about 6ms
 
         qint64 padding = m_timeSinceLastVBlank;
         if (padding > fpsInterval) {
             // We're at low repaints or spent more time in painting than the user wanted to wait
             // for that frame. Align to next vblank:
             padding = vBlankInterval - (padding % vBlankInterval);
         } else {
             // Align to the next maxFps tick:
             // "remaining time of the first vsync" + "time for the other vsyncs of the frame"
             padding = ((vBlankInterval - padding % vBlankInterval) +
                        (fpsInterval / vBlankInterval - 1) * vBlankInterval);
         }
 
         if (padding < options->vBlankTime()) {
             // We'll likely miss this frame so we add one:
             waitTime = nanoToMilli(padding + vBlankInterval - options->vBlankTime());
         } else {
             waitTime = nanoToMilli(padding - options->vBlankTime());
         }
     }
     else { // w/o blocking vsync we just jump to the next demanded tick
         if (fpsInterval > m_timeSinceLastVBlank) {
             waitTime = nanoToMilli(fpsInterval - m_timeSinceLastVBlank);
             if (!waitTime) {
                 // Will ensure we don't block out the eventloop - the system's just not faster ...
                 waitTime = 1;
             }
         }
         /* else if (m_scene->syncsToVBlank() && m_timeSinceLastVBlank - fpsInterval < (vBlankInterval<<1)) {
             // NOTICE - "for later" ------------------------------------------------------------------
             // It can happen that we push two frames within one refresh cycle.
             // Swapping will then block even with triple buffering when the GPU does not discard but
             // queues frames
             // now here's the mean part: if we take that as "OMG, we're late - next frame ASAP",
             // there'll immediately be 2 frames in the pipe, swapping will block, we think we're
             // late ... ewww
             // so instead we pad to the clock again and add 2ms safety to ensure the pipe is really
             // free
             // NOTICE: obviously m_timeSinceLastVBlank can be too big because we're too slow as well
             // So if this code was enabled, we'd needlessly half the framerate once more (15 instead of 30)
             waitTime = nanoToMilli(vBlankInterval - (m_timeSinceLastVBlank - fpsInterval)%vBlankInterval) + 2;
         }*/
         else {
             // "0" would be sufficient here, but the compositor isn't the WMs only task.
             waitTime = 1;
         }
     }
     // Force 4fps minimum:
     compositeTimer.start(qMin(waitTime, 250u), this);
 }
 
 bool Compositor::isActive()
 {
     return m_state == State::On;
 }
 
 WaylandCompositor::WaylandCompositor(QObject *parent)
     : Compositor(parent)
 {
     connect(kwinApp(), &Application::x11ConnectionAboutToBeDestroyed,
             this, &WaylandCompositor::destroyCompositorSelection);
 }
 
 void WaylandCompositor::toggleCompositing()
 {
     // For the shortcut. Not possible on Wayland because we always composite.
 }
 
 void WaylandCompositor::start()
 {
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
 
     if (Workspace::self()) {
         startupWithWorkspace();
     } else {
         connect(kwinApp(), &Application::workspaceCreated,
                 this, &WaylandCompositor::startupWithWorkspace);
     }
 }
 
 int WaylandCompositor::refreshRate() const
 {
     // TODO: This makes no sense on Wayland. First step would be to atleast
     //       set the refresh rate to the highest available one. Second step
     //       would be to not use a uniform value at all but per screen.
     return KWin::currentRefreshRate();
 }
 
 X11Compositor::X11Compositor(QObject *parent)
     : Compositor(parent)
     , m_suspended(options->isUseCompositing() ? NoReasonSuspend : UserSuspend)
     , m_xrrRefreshRate(0)
 {
 }
 
 void X11Compositor::toggleCompositing()
 {
     if (m_suspended) {
         // Direct user call; clear all bits.
         resume(AllReasonSuspend);
     } else {
         // But only set the user one (sufficient to suspend).
         suspend(UserSuspend);
     }
 }
 
 void X11Compositor::reinitialize()
 {
     // Resume compositing if suspended.
     m_suspended = NoReasonSuspend;
     Compositor::reinitialize();
 }
 
 void X11Compositor::configChanged()
 {
     if (m_suspended) {
         stop();
         return;
     }
     Compositor::configChanged();
 }
 
 void X11Compositor::suspend(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended |= reason;
 
     if (reason & ScriptSuspend) {
         // When disabled show a shortcut how the user can get back compositing.
         const auto shortcuts = KGlobalAccel::self()->shortcut(
             workspace()->findChild<QAction*>(QStringLiteral("Suspend Compositing")));
         if (!shortcuts.isEmpty()) {
             // Display notification only if there is the shortcut.
             const QString message =
                     i18n("Desktop effects have been suspended by another application.<br/>"
                          "You can resume using the '%1' shortcut.",
                          shortcuts.first().toString(QKeySequence::NativeText));
             KNotification::event(QStringLiteral("compositingsuspendeddbus"), message);
         }
     }
     stop();
 }
 
 void X11Compositor::resume(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended &= ~reason;
     start();
 }
 
 void X11Compositor::start()
 {
     if (m_suspended) {
         QStringList reasons;
         if (m_suspended & UserSuspend) {
             reasons << QStringLiteral("Disabled by User");
         }
         if (m_suspended & BlockRuleSuspend) {
             reasons << QStringLiteral("Disabled by Window");
         }
         if (m_suspended & ScriptSuspend) {
             reasons << QStringLiteral("Disabled by Script");
         }
         qCDebug(KWIN_CORE) << "Compositing is suspended, reason:" << reasons;
         return;
     } else if (!kwinApp()->platform()->compositingPossible()) {
         qCCritical(KWIN_CORE) << "Compositing is not possible";
         return;
     }
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
     m_xrrRefreshRate = KWin::currentRefreshRate();
     startupWithWorkspace();
 }
 void X11Compositor::performCompositing()
 {
     if (scene()->usesOverlayWindow() && !isOverlayWindowVisible()) {
         // Return since nothing is visible.
         return;
     }
     Compositor::performCompositing();
 }
 
 bool X11Compositor::checkForOverlayWindow(WId w) const
 {
     if (!scene()) {
         // No scene, so it cannot be the overlay window.
         return false;
     }
     if (!scene()->overlayWindow()) {
         // No overlay window, it cannot be the overlay.
         return false;
     }
     // Compare the window ID's.
     return w == scene()->overlayWindow()->window();
 }
 
 bool X11Compositor::isOverlayWindowVisible() const
 {
     if (!scene()) {
         return false;
     }
     if (!scene()->overlayWindow()) {
         return false;
     }
     return scene()->overlayWindow()->isVisible();
 }
 
 int X11Compositor::refreshRate() const
 {
     return m_xrrRefreshRate;
 }
 
 void X11Compositor::updateClientCompositeBlocking(X11Client *c)
 {
     if (c) {
         if (c->isBlockingCompositing()) {
             // Do NOT attempt to call suspend(true) from within the eventchain!
             if (!(m_suspended & BlockRuleSuspend))
                 QMetaObject::invokeMethod(this, [this]() {
                         suspend(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
     else if (m_suspended & BlockRuleSuspend) {
         // If !c we just check if we can resume in case a blocking client was lost.
         bool shouldResume = true;
 
         for (auto it = Workspace::self()->clientList().constBegin();
              it != Workspace::self()->clientList().constEnd(); ++it) {
             if ((*it)->isBlockingCompositing()) {
                 shouldResume = false;
                 break;
             }
         }
         if (shouldResume) {
             // Do NOT attempt to call suspend(false) from within the eventchain!
                 QMetaObject::invokeMethod(this, [this]() {
                         resume(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
 }
 
 X11Compositor *X11Compositor::self()
 {
     return qobject_cast<X11Compositor *>(Compositor::self());
 }
 
 }
 
 // included for CompositorSelectionOwner
 #include "composite.moc"
diff --git a/debug_console.cpp b/debug_console.cpp
index c0f012ff3..557337988 100644
--- a/debug_console.cpp
+++ b/debug_console.cpp
@@ -1,1596 +1,1595 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "debug_console.h"
 #include "composite.h"
 #include "x11client.h"
 #include "input_event.h"
 #include "internal_client.h"
 #include "main.h"
 #include "scene.h"
-#include "xdgshellclient.h"
 #include "unmanaged.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "keyboard_input.h"
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 
 #include "ui_debug_console.h"
 
 // KWayland
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/clientconnection.h>
 #include <KWayland/Server/subcompositor_interface.h>
 #include <KWayland/Server/surface_interface.h>
 // frameworks
 #include <KLocalizedString>
 #include <NETWM>
 // Qt
 #include <QMouseEvent>
 #include <QMetaProperty>
 #include <QMetaType>
 
 // xkb
 #include <xkbcommon/xkbcommon.h>
 
 #include <functional>
 
 namespace KWin
 {
 
 
 static QString tableHeaderRow(const QString &title)
 {
     return QStringLiteral("<tr><th colspan=\"2\">%1</th></tr>").arg(title);
 }
 
 template<typename T>
 static
 QString tableRow(const QString &title, const T &argument)
 {
     return QStringLiteral("<tr><td>%1</td><td>%2</td></tr>").arg(title).arg(argument);
 }
 
 static QString timestampRow(quint32 timestamp)
 {
     return tableRow(i18n("Timestamp"), timestamp);
 }
 
 static QString timestampRowUsec(quint64 timestamp)
 {
     return tableRow(i18n("Timestamp (µsec)"), timestamp);
 }
 
 static QString buttonToString(Qt::MouseButton button)
 {
     switch (button) {
         case Qt::LeftButton:
             return i18nc("A mouse button", "Left");
         case Qt::RightButton:
             return i18nc("A mouse button", "Right");
         case Qt::MiddleButton:
             return i18nc("A mouse button", "Middle");
         case Qt::BackButton:
             return i18nc("A mouse button", "Back");
         case Qt::ForwardButton:
             return i18nc("A mouse button", "Forward");
         case Qt::TaskButton:
             return i18nc("A mouse button", "Task");
         case Qt::ExtraButton4:
             return i18nc("A mouse button", "Extra Button 4");
         case Qt::ExtraButton5:
             return i18nc("A mouse button", "Extra Button 5");
         case Qt::ExtraButton6:
             return i18nc("A mouse button", "Extra Button 6");
         case Qt::ExtraButton7:
             return i18nc("A mouse button", "Extra Button 7");
         case Qt::ExtraButton8:
             return i18nc("A mouse button", "Extra Button 8");
         case Qt::ExtraButton9:
             return i18nc("A mouse button", "Extra Button 9");
         case Qt::ExtraButton10:
             return i18nc("A mouse button", "Extra Button 10");
         case Qt::ExtraButton11:
             return i18nc("A mouse button", "Extra Button 11");
         case Qt::ExtraButton12:
             return i18nc("A mouse button", "Extra Button 12");
         case Qt::ExtraButton13:
             return i18nc("A mouse button", "Extra Button 13");
         case Qt::ExtraButton14:
             return i18nc("A mouse button", "Extra Button 14");
         case Qt::ExtraButton15:
             return i18nc("A mouse button", "Extra Button 15");
         case Qt::ExtraButton16:
             return i18nc("A mouse button", "Extra Button 16");
         case Qt::ExtraButton17:
             return i18nc("A mouse button", "Extra Button 17");
         case Qt::ExtraButton18:
             return i18nc("A mouse button", "Extra Button 18");
         case Qt::ExtraButton19:
             return i18nc("A mouse button", "Extra Button 19");
         case Qt::ExtraButton20:
             return i18nc("A mouse button", "Extra Button 20");
         case Qt::ExtraButton21:
             return i18nc("A mouse button", "Extra Button 21");
         case Qt::ExtraButton22:
             return i18nc("A mouse button", "Extra Button 22");
         case Qt::ExtraButton23:
             return i18nc("A mouse button", "Extra Button 23");
         case Qt::ExtraButton24:
             return i18nc("A mouse button", "Extra Button 24");
     default:
         return QString();
     }
 }
 
 static QString deviceRow(LibInput::Device *device)
 {
     if (!device) {
         return tableRow(i18n("Input Device"), i18nc("The input device of the event is not known", "Unknown"));
     }
     return tableRow(i18n("Input Device"), QStringLiteral("%1 (%2)").arg(device->name()).arg(device->sysName()));
 }
 
 static QString buttonsToString(Qt::MouseButtons buttons)
 {
     QString ret;
     for (uint i = 1; i < Qt::ExtraButton24; i = i << 1) {
         if (buttons & i) {
             ret.append(buttonToString(Qt::MouseButton(uint(buttons) & i)));
             ret.append(QStringLiteral(" "));
         }
     };
     return ret.trimmed();
 }
 
 static const QString s_hr = QStringLiteral("<hr/>");
 static const QString s_tableStart = QStringLiteral("<table>");
 static const QString s_tableEnd = QStringLiteral("</table>");
 
 DebugConsoleFilter::DebugConsoleFilter(QTextEdit *textEdit)
     : InputEventSpy()
     , m_textEdit(textEdit)
 {
 }
 
 DebugConsoleFilter::~DebugConsoleFilter() = default;
 
 void DebugConsoleFilter::pointerEvent(MouseEvent *event)
 {
     QString text = s_hr;
     const QString timestamp = timestampRow(event->timestamp());
 
     text.append(s_tableStart);
     switch (event->type()) {
     case QEvent::MouseMove: {
         text.append(tableHeaderRow(i18nc("A mouse pointer motion event", "Pointer Motion")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         if (event->timestampMicroseconds() != 0) {
             text.append(timestampRowUsec(event->timestampMicroseconds()));
         }
         if (event->delta() != QSizeF()) {
             text.append(tableRow(i18nc("The relative mouse movement", "Delta"),
                                  QStringLiteral("%1/%2").arg(event->delta().width()).arg(event->delta().height())));
         }
         if (event->deltaUnaccelerated() != QSizeF()) {
             text.append(tableRow(i18nc("The relative mouse movement", "Delta (not accelerated)"),
                                  QStringLiteral("%1/%2").arg(event->deltaUnaccelerated().width()).arg(event->deltaUnaccelerated().height())));
         }
         text.append(tableRow(i18nc("The global mouse pointer position", "Global Position"), QStringLiteral("%1/%2").arg(event->pos().x()).arg(event->pos().y())));
         break;
     }
     case QEvent::MouseButtonPress:
         text.append(tableHeaderRow(i18nc("A mouse pointer button press event", "Pointer Button Press")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Button"), buttonToString(event->button())));
         text.append(tableRow(i18nc("A button in a mouse press/release event",  "Native Button code"), event->nativeButton()));
         text.append(tableRow(i18nc("All currently pressed buttons in a mouse press/release event", "Pressed Buttons"), buttonsToString(event->buttons())));
         break;
     case QEvent::MouseButtonRelease:
         text.append(tableHeaderRow(i18nc("A mouse pointer button release event", "Pointer Button Release")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Button"), buttonToString(event->button())));
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Native Button code"), event->nativeButton()));
         text.append(tableRow(i18nc("All currently pressed buttons in a mouse press/release event", "Pressed Buttons"), buttonsToString(event->buttons())));
         break;
     default:
         break;
     }
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::wheelEvent(WheelEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A mouse pointer axis (wheel) event", "Pointer Axis")));
     text.append(deviceRow(event->device()));
     text.append(timestampRow(event->timestamp()));
     const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
     text.append(tableRow(i18nc("The orientation of a pointer axis event", "Orientation"),
                          orientation == Qt::Horizontal ? i18nc("An orientation of a pointer axis event", "Horizontal")
                                                        : i18nc("An orientation of a pointer axis event", "Vertical")));
     text.append(tableRow(i18nc("The angle delta of a pointer axis event", "Delta"),
                          orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::keyEvent(KeyEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
 
     switch (event->type()) {
     case QEvent::KeyPress:
         text.append(tableHeaderRow(i18nc("A key press event", "Key Press")));
         break;
     case QEvent::KeyRelease:
         text.append(tableHeaderRow(i18nc("A key release event", "Key Release")));
         break;
     default:
         break;
     }
     text.append(deviceRow(event->device()));
     auto modifiersToString = [event] {
         QString ret;
         if (event->modifiers().testFlag(Qt::ShiftModifier)) {
             ret.append(i18nc("A keyboard modifier", "Shift"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::ControlModifier)) {
             ret.append(i18nc("A keyboard modifier", "Control"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::AltModifier)) {
             ret.append(i18nc("A keyboard modifier", "Alt"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::MetaModifier)) {
             ret.append(i18nc("A keyboard modifier", "Meta"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::KeypadModifier)) {
             ret.append(i18nc("A keyboard modifier", "Keypad"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::GroupSwitchModifier)) {
             ret.append(i18nc("A keyboard modifier", "Group-switch"));
             ret.append(QStringLiteral(" "));
         }
         return ret;
     };
     text.append(timestampRow(event->timestamp()));
     text.append(tableRow(i18nc("Whether the event is an automatic key repeat", "Repeat"), event->isAutoRepeat()));
 
     const auto keyMetaObject = Qt::qt_getEnumMetaObject(Qt::Key());
     const auto enumerator = keyMetaObject->enumerator(keyMetaObject->indexOfEnumerator("Key"));
     text.append(tableRow(i18nc("The code as read from the input device", "Scan code"), event->nativeScanCode()));
     text.append(tableRow(i18nc("Key according to Qt", "Qt::Key code"),
                          enumerator.valueToKey(event->key())));
     text.append(tableRow(i18nc("The translated code to an Xkb symbol", "Xkb symbol"), event->nativeVirtualKey()));
     text.append(tableRow(i18nc("The translated code interpreted as text", "Utf8"), event->text()));
     text.append(tableRow(i18nc("The currently active modifiers", "Modifiers"), modifiersToString()));
 
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch down event", "Touch down")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(tableRow(i18nc("The global position of the touch point", "Global position"),
                          QStringLiteral("%1/%2").arg(pos.x()).arg(pos.y())));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch motion event", "Touch Motion")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(tableRow(i18nc("The global position of the touch point", "Global position"),
                          QStringLiteral("%1/%2").arg(pos.x()).arg(pos.y())));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchUp(qint32 id, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch up event", "Touch Up")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureBegin(int fingerCount, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture is started", "Pinch start")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Number of fingers in this pinch gesture", "Finger count"), fingerCount));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture is updated", "Pinch update")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Current scale in pinch gesture", "Scale"), scale));
     text.append(tableRow(i18nc("Current angle in pinch gesture", "Angle delta"), angleDelta));
     text.append(tableRow(i18nc("Current delta in pinch gesture", "Delta x"), delta.width()));
     text.append(tableRow(i18nc("Current delta in pinch gesture", "Delta y"), delta.height()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureEnd(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture ended", "Pinch end")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureCancelled(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture got cancelled", "Pinch cancelled")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureBegin(int fingerCount, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture is started", "Swipe start")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Number of fingers in this swipe gesture", "Finger count"), fingerCount));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture is updated", "Swipe update")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Current delta in swipe gesture", "Delta x"), delta.width()));
     text.append(tableRow(i18nc("Current delta in swipe gesture", "Delta y"), delta.height()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureEnd(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture ended", "Swipe end")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureCancelled(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture got cancelled", "Swipe cancelled")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::switchEvent(SwitchEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A hardware switch (e.g. notebook lid) got toggled", "Switch toggled")));
     text.append(timestampRow(event->timestamp()));
     if (event->timestampMicroseconds() != 0) {
         text.append(timestampRowUsec(event->timestampMicroseconds()));
     }
     text.append(deviceRow(event->device()));
     QString switchName;
     if (event->device()->isLidSwitch()) {
         switchName = i18nc("Name of a hardware switch", "Notebook lid");
     } else if (event->device()->isTabletModeSwitch()) {
         switchName = i18nc("Name of a hardware switch", "Tablet mode");
     }
     text.append(tableRow(i18nc("A hardware switch", "Switch"), switchName));
     QString switchState;
     switch (event->state()) {
     case SwitchEvent::State::Off:
         switchState = i18nc("The hardware switch got turned off", "Off");
         break;
     case SwitchEvent::State::On:
         switchState = i18nc("The hardware switch got turned on", "On");
         break;
     default:
         Q_UNREACHABLE();
     }
     text.append(tableRow(i18nc("State of a hardware switch (on/off)", "State"), switchState));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletToolEvent(QTabletEvent *event)
 {
     QString typeString;
     {
         QDebug d(&typeString);
         d << event->type();
     }
 
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Tool"))
                  + tableRow(i18n("EventType"), typeString)
                  + tableRow(i18n("Position"),
                             QStringLiteral("%1,%2").arg(event->pos().x()).arg(event->pos().y()))
                  + tableRow(i18n("Tilt"),
                             QStringLiteral("%1,%2").arg(event->xTilt()).arg(event->yTilt()))
                  + tableRow(i18n("Rotation"), QString::number(event->rotation()))
                  + tableRow(i18n("Pressure"), QString::number(event->pressure()))
                  + tableRow(i18n("Buttons"), QString::number(event->buttons()))
                  + tableRow(i18n("Modifiers"), QString::number(event->modifiers()))
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletToolButtonEvent(const QSet<uint> &pressedButtons)
 {
     QString buttons;
     for (uint b : pressedButtons) {
         buttons += QString::number(b) + ' ';
     }
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Tool Button"))
                  + tableRow(i18n("Pressed Buttons"), buttons)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadButtonEvent(const QSet<uint> &pressedButtons)
 {
     QString buttons;
     for (uint b : pressedButtons) {
         buttons += QString::number(b) + ' ';
     }
     QString text = s_hr + s_tableStart
                  + tableHeaderRow(i18n("Tablet Pad Button"))
                  + tableRow(i18n("Pressed Buttons"), buttons)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Pad Strip"))
                  + tableRow(i18n("Number"), number)
                  + tableRow(i18n("Position"), position)
                  + tableRow(i18n("isFinger"), isFinger)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Pad Ring"))
                  + tableRow(i18n("Number"), number)
                  + tableRow(i18n("Position"), position)
                  + tableRow(i18n("isFinger"), isFinger)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 DebugConsole::DebugConsole()
     : QWidget()
     , m_ui(new Ui::DebugConsole)
 {
     setAttribute(Qt::WA_ShowWithoutActivating);
     m_ui->setupUi(this);
     m_ui->windowsView->setItemDelegate(new DebugConsoleDelegate(this));
     m_ui->windowsView->setModel(new DebugConsoleModel(this));
     m_ui->surfacesView->setModel(new SurfaceTreeModel(this));
     if (kwinApp()->usesLibinput()) {
         m_ui->inputDevicesView->setModel(new InputDeviceModel(this));
         m_ui->inputDevicesView->setItemDelegate(new DebugConsoleDelegate(this));
     }
     m_ui->quitButton->setIcon(QIcon::fromTheme(QStringLiteral("application-exit")));
     m_ui->tabWidget->setTabIcon(0, QIcon::fromTheme(QStringLiteral("view-list-tree")));
     m_ui->tabWidget->setTabIcon(1, QIcon::fromTheme(QStringLiteral("view-list-tree")));
 
     if (kwinApp()->operationMode() == Application::OperationMode::OperationModeX11) {
         m_ui->tabWidget->setTabEnabled(1, false);
         m_ui->tabWidget->setTabEnabled(2, false);
     }
     if (!kwinApp()->usesLibinput()) {
         m_ui->tabWidget->setTabEnabled(3, false);
     }
 
     connect(m_ui->quitButton, &QAbstractButton::clicked, this, &DebugConsole::deleteLater);
     connect(m_ui->tabWidget, &QTabWidget::currentChanged, this,
         [this] (int index) {
             // delay creation of input event filter until the tab is selected
             if (index == 2 && m_inputFilter.isNull()) {
                 m_inputFilter.reset(new DebugConsoleFilter(m_ui->inputTextEdit));
                 input()->installInputEventSpy(m_inputFilter.data());
             }
             if (index == 5) {
                 updateKeyboardTab();
                 connect(input(), &InputRedirection::keyStateChanged, this, &DebugConsole::updateKeyboardTab);
             }
         }
     );
 
     // for X11
     setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     initGLTab();
 }
 
 DebugConsole::~DebugConsole() = default;
 
 void DebugConsole::initGLTab()
 {
     if (!effects || !effects->isOpenGLCompositing()) {
         m_ui->noOpenGLLabel->setVisible(true);
         m_ui->glInfoScrollArea->setVisible(false);
         return;
     }
     GLPlatform *gl = GLPlatform::instance();
     m_ui->noOpenGLLabel->setVisible(false);
     m_ui->glInfoScrollArea->setVisible(true);
     m_ui->glVendorStringLabel->setText(QString::fromLocal8Bit(gl->glVendorString()));
     m_ui->glRendererStringLabel->setText(QString::fromLocal8Bit(gl->glRendererString()));
     m_ui->glVersionStringLabel->setText(QString::fromLocal8Bit(gl->glVersionString()));
     m_ui->glslVersionStringLabel->setText(QString::fromLocal8Bit(gl->glShadingLanguageVersionString()));
     m_ui->glDriverLabel->setText(GLPlatform::driverToString(gl->driver()));
     m_ui->glGPULabel->setText(GLPlatform::chipClassToString(gl->chipClass()));
     m_ui->glVersionLabel->setText(GLPlatform::versionToString(gl->glVersion()));
     m_ui->glslLabel->setText(GLPlatform::versionToString(gl->glslVersion()));
 
     auto extensionsString = [] (const auto &extensions) {
         QString text = QStringLiteral("<ul>");
         for (auto extension : extensions) {
             text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(extension)));
         }
         text.append(QStringLiteral("</ul>"));
         return text;
     };
 
     m_ui->platformExtensionsLabel->setText(extensionsString(Compositor::self()->scene()->openGLPlatformInterfaceExtensions()));
     m_ui->openGLExtensionsLabel->setText(extensionsString(openGLExtensions()));
 }
 
 template <typename T>
 QString keymapComponentToString(xkb_keymap *map, const T &count, std::function<const char*(xkb_keymap*,T)> f)
 {
     QString text = QStringLiteral("<ul>");
     for (T i = 0; i < count; i++) {
         text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(f(map, i))));
     }
     text.append(QStringLiteral("</ul>"));
     return text;
 }
 
 template <typename T>
 QString stateActiveComponents(xkb_state *state, const T &count, std::function<int(xkb_state*,T)> f, std::function<const char*(xkb_keymap*,T)> name)
 {
     QString text = QStringLiteral("<ul>");
     xkb_keymap *map = xkb_state_get_keymap(state);
     for (T i = 0; i < count; i++) {
         if (f(state, i) == 1) {
             text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(name(map, i))));
         }
     }
     text.append(QStringLiteral("</ul>"));
     return text;
 }
 
 void DebugConsole::updateKeyboardTab()
 {
     auto xkb = input()->keyboard()->xkb();
     xkb_keymap *map = xkb->keymap();
     xkb_state *state = xkb->state();
     m_ui->layoutsLabel->setText(keymapComponentToString<xkb_layout_index_t>(map, xkb_keymap_num_layouts(map), &xkb_keymap_layout_get_name));
     m_ui->currentLayoutLabel->setText(xkb_keymap_layout_get_name(map, xkb->currentLayout()));
     m_ui->modifiersLabel->setText(keymapComponentToString<xkb_mod_index_t>(map, xkb_keymap_num_mods(map), &xkb_keymap_mod_get_name));
     m_ui->ledsLabel->setText(keymapComponentToString<xkb_led_index_t>(map, xkb_keymap_num_leds(map), &xkb_keymap_led_get_name));
     m_ui->activeLedsLabel->setText(stateActiveComponents<xkb_led_index_t>(state, xkb_keymap_num_leds(map), &xkb_state_led_index_is_active, &xkb_keymap_led_get_name));
 
     using namespace std::placeholders;
     auto modActive = std::bind(xkb_state_mod_index_is_active, _1, _2, XKB_STATE_MODS_EFFECTIVE);
     m_ui->activeModifiersLabel->setText(stateActiveComponents<xkb_mod_index_t>(state, xkb_keymap_num_mods(map), modActive, &xkb_keymap_mod_get_name));
 }
 
 void DebugConsole::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     // delay the connection to the show event as in ctor the windowHandle returns null
     connect(windowHandle(), &QWindow::visibleChanged, this,
         [this] (bool visible) {
             if (visible) {
                 // ignore
                 return;
             }
             deleteLater();
         }
     );
 }
 
 DebugConsoleDelegate::DebugConsoleDelegate(QObject *parent)
     : QStyledItemDelegate(parent)
 {
 }
 
 DebugConsoleDelegate::~DebugConsoleDelegate() = default;
 
 QString DebugConsoleDelegate::displayText(const QVariant &value, const QLocale &locale) const
 {
     switch (value.type()) {
     case QMetaType::QPoint: {
         const QPoint p = value.toPoint();
         return QStringLiteral("%1,%2").arg(p.x()).arg(p.y());
     }
     case QMetaType::QPointF: {
         const QPointF p = value.toPointF();
         return QStringLiteral("%1,%2").arg(p.x()).arg(p.y());
     }
     case QMetaType::QSize: {
         const QSize s = value.toSize();
         return QStringLiteral("%1x%2").arg(s.width()).arg(s.height());
     }
     case QMetaType::QSizeF: {
         const QSizeF s = value.toSizeF();
         return QStringLiteral("%1x%2").arg(s.width()).arg(s.height());
     }
     case QMetaType::QRect: {
         const QRect r = value.toRect();
         return QStringLiteral("%1,%2 %3x%4").arg(r.x()).arg(r.y()).arg(r.width()).arg(r.height());
     }
     default:
         if (value.userType() == qMetaTypeId<KWayland::Server::SurfaceInterface*>()) {
             if (auto s = value.value<KWayland::Server::SurfaceInterface*>()) {
                 return QStringLiteral("KWayland::Server::SurfaceInterface(0x%1)").arg(qulonglong(s), 0, 16);
             } else {
                 return QStringLiteral("nullptr");
             }
         }
         if (value.userType() == qMetaTypeId<Qt::MouseButtons>()) {
             const auto buttons = value.value<Qt::MouseButtons>();
             if (buttons == Qt::NoButton) {
                 return i18n("No Mouse Buttons");
             }
             QStringList list;
             if (buttons.testFlag(Qt::LeftButton)) {
                 list << i18nc("Mouse Button", "left");
             }
             if (buttons.testFlag(Qt::RightButton)) {
                 list << i18nc("Mouse Button", "right");
             }
             if (buttons.testFlag(Qt::MiddleButton)) {
                 list << i18nc("Mouse Button", "middle");
             }
             if (buttons.testFlag(Qt::BackButton)) {
                 list << i18nc("Mouse Button", "back");
             }
             if (buttons.testFlag(Qt::ForwardButton)) {
                 list << i18nc("Mouse Button", "forward");
             }
             if (buttons.testFlag(Qt::ExtraButton1)) {
                 list << i18nc("Mouse Button", "extra 1");
             }
             if (buttons.testFlag(Qt::ExtraButton2)) {
                 list << i18nc("Mouse Button", "extra 2");
             }
             if (buttons.testFlag(Qt::ExtraButton3)) {
                 list << i18nc("Mouse Button", "extra 3");
             }
             if (buttons.testFlag(Qt::ExtraButton4)) {
                 list << i18nc("Mouse Button", "extra 4");
             }
             if (buttons.testFlag(Qt::ExtraButton5)) {
                 list << i18nc("Mouse Button", "extra 5");
             }
             if (buttons.testFlag(Qt::ExtraButton6)) {
                 list << i18nc("Mouse Button", "extra 6");
             }
             if (buttons.testFlag(Qt::ExtraButton7)) {
                 list << i18nc("Mouse Button", "extra 7");
             }
             if (buttons.testFlag(Qt::ExtraButton8)) {
                 list << i18nc("Mouse Button", "extra 8");
             }
             if (buttons.testFlag(Qt::ExtraButton9)) {
                 list << i18nc("Mouse Button", "extra 9");
             }
             if (buttons.testFlag(Qt::ExtraButton10)) {
                 list << i18nc("Mouse Button", "extra 10");
             }
             if (buttons.testFlag(Qt::ExtraButton11)) {
                 list << i18nc("Mouse Button", "extra 11");
             }
             if (buttons.testFlag(Qt::ExtraButton12)) {
                 list << i18nc("Mouse Button", "extra 12");
             }
             if (buttons.testFlag(Qt::ExtraButton13)) {
                 list << i18nc("Mouse Button", "extra 13");
             }
             if (buttons.testFlag(Qt::ExtraButton14)) {
                 list << i18nc("Mouse Button", "extra 14");
             }
             if (buttons.testFlag(Qt::ExtraButton15)) {
                 list << i18nc("Mouse Button", "extra 15");
             }
             if (buttons.testFlag(Qt::ExtraButton16)) {
                 list << i18nc("Mouse Button", "extra 16");
             }
             if (buttons.testFlag(Qt::ExtraButton17)) {
                 list << i18nc("Mouse Button", "extra 17");
             }
             if (buttons.testFlag(Qt::ExtraButton18)) {
                 list << i18nc("Mouse Button", "extra 18");
             }
             if (buttons.testFlag(Qt::ExtraButton19)) {
                 list << i18nc("Mouse Button", "extra 19");
             }
             if (buttons.testFlag(Qt::ExtraButton20)) {
                 list << i18nc("Mouse Button", "extra 20");
             }
             if (buttons.testFlag(Qt::ExtraButton21)) {
                 list << i18nc("Mouse Button", "extra 21");
             }
             if (buttons.testFlag(Qt::ExtraButton22)) {
                 list << i18nc("Mouse Button", "extra 22");
             }
             if (buttons.testFlag(Qt::ExtraButton23)) {
                 list << i18nc("Mouse Button", "extra 23");
             }
             if (buttons.testFlag(Qt::ExtraButton24)) {
                 list << i18nc("Mouse Button", "extra 24");
             }
             if (buttons.testFlag(Qt::TaskButton)) {
                 list << i18nc("Mouse Button", "task");
             }
             return list.join(QStringLiteral(", "));
         }
         break;
     }
     return QStyledItemDelegate::displayText(value, locale);
 }
 
 static const int s_x11ClientId = 1;
 static const int s_x11UnmanagedId = 2;
 static const int s_waylandClientId = 3;
 static const int s_workspaceInternalId = 4;
 static const quint32 s_propertyBitMask = 0xFFFF0000;
 static const quint32 s_clientBitMask   = 0x0000FFFF;
 static const quint32 s_idDistance = 10000;
 
 template <class T>
 void DebugConsoleModel::add(int parentRow, QVector<T*> &clients, T *client)
 {
     beginInsertRows(index(parentRow, 0, QModelIndex()), clients.count(), clients.count());
     clients.append(client);
     endInsertRows();
 }
 
 template <class T>
 void DebugConsoleModel::remove(int parentRow, QVector<T*> &clients, T *client)
 {
     const int remove = clients.indexOf(client);
     if (remove == -1) {
         return;
     }
     beginRemoveRows(index(parentRow, 0, QModelIndex()), remove, remove);
     clients.removeAt(remove);
     endRemoveRows();
 }
 
 DebugConsoleModel::DebugConsoleModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
     if (waylandServer()) {
         const auto clients = waylandServer()->clients();
         for (auto c : clients) {
-            m_shellClients.append(c);
+            m_waylandClients.append(c);
         }
         // TODO: that only includes windows getting shown, not those which are only created
         connect(waylandServer(), &WaylandServer::shellClientAdded, this,
-            [this] (XdgShellClient *c) {
-                add(s_waylandClientId -1, m_shellClients, c);
+            [this] (AbstractClient *c) {
+                add(s_waylandClientId -1, m_waylandClients, c);
             }
         );
         connect(waylandServer(), &WaylandServer::shellClientRemoved, this,
-            [this] (XdgShellClient *c) {
-                remove(s_waylandClientId -1, m_shellClients, c);
+            [this] (AbstractClient *c) {
+                remove(s_waylandClientId -1, m_waylandClients, c);
             }
         );
     }
     const auto x11Clients = workspace()->clientList();
     for (auto c : x11Clients) {
         m_x11Clients.append(c);
     }
     const auto x11DesktopClients = workspace()->desktopList();
     for (auto c : x11DesktopClients) {
         m_x11Clients.append(c);
     }
     connect(workspace(), &Workspace::clientAdded, this,
         [this] (X11Client *c) {
             add(s_x11ClientId -1, m_x11Clients, c);
         }
     );
     connect(workspace(), &Workspace::clientRemoved, this,
         [this] (AbstractClient *ac) {
             X11Client *c = qobject_cast<X11Client *>(ac);
             if (!c) {
                 return;
             }
             remove(s_x11ClientId -1, m_x11Clients, c);
         }
     );
 
     const auto unmangeds = workspace()->unmanagedList();
     for (auto u : unmangeds) {
         m_unmanageds.append(u);
     }
     connect(workspace(), &Workspace::unmanagedAdded, this,
         [this] (Unmanaged *u) {
             add(s_x11UnmanagedId -1, m_unmanageds, u);
         }
     );
     connect(workspace(), &Workspace::unmanagedRemoved, this,
         [this] (Unmanaged *u) {
             remove(s_x11UnmanagedId -1, m_unmanageds, u);
         }
     );
     for (InternalClient *client : workspace()->internalClients()) {
         m_internalClients.append(client);
     }
     connect(workspace(), &Workspace::internalClientAdded, this,
         [this](InternalClient *client) {
             add(s_workspaceInternalId -1, m_internalClients, client);
         }
     );
     connect(workspace(), &Workspace::internalClientRemoved, this,
         [this](InternalClient *client) {
             remove(s_workspaceInternalId -1, m_internalClients, client);
         }
     );
 }
 
 DebugConsoleModel::~DebugConsoleModel() = default;
 
 int DebugConsoleModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 2;
 }
 
 int DebugConsoleModel::topLevelRowCount() const
 {
     return kwinApp()->shouldUseWaylandForCompositing() ? 4 : 2;
 }
 
 template <class T>
 int DebugConsoleModel::propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const
 {
     if (T *t = (this->*filter)(parent)) {
         return t->metaObject()->propertyCount();
     }
     return 0;
 }
 
 int DebugConsoleModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return topLevelRowCount();
     }
 
     switch (parent.internalId()) {
     case s_x11ClientId:
         return m_x11Clients.count();
     case s_x11UnmanagedId:
         return m_unmanageds.count();
     case s_waylandClientId:
-        return m_shellClients.count();
+        return m_waylandClients.count();
     case s_workspaceInternalId:
         return m_internalClients.count();
     default:
         break;
     }
 
     if (parent.internalId() & s_propertyBitMask) {
         // properties do not have children
         return 0;
     }
 
     if (parent.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::x11Client);
     } else if (parent.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::unmanaged);
     } else if (parent.internalId() < s_idDistance * (s_waylandClientId + 1)) {
-        return propertyCount(parent, &DebugConsoleModel::shellClient);
+        return propertyCount(parent, &DebugConsoleModel::waylandClient);
     } else if (parent.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::internalClient);
     }
 
     return 0;
 }
 
 template <class T>
 QModelIndex DebugConsoleModel::indexForClient(int row, int column, const QVector<T*> &clients, int id) const
 {
     if (column != 0) {
         return QModelIndex();
     }
     if (row >= clients.count()) {
         return QModelIndex();
     }
     return createIndex(row, column, s_idDistance * id + row);
 }
 
 template <class T>
 QModelIndex DebugConsoleModel::indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const
 {
     if (T *t = (this->*filter)(parent)) {
         if (row >= t->metaObject()->propertyCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, quint32(row + 1) << 16 | parent.internalId());
     }
     return QModelIndex();
 }
 
 QModelIndex DebugConsoleModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         // index for a top level item
         if (column != 0 || row >= topLevelRowCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, row + 1);
     }
     if (column >= 2) {
         // max of 2 columns
         return QModelIndex();
     }
     // index for a client (second level)
     switch (parent.internalId()) {
     case s_x11ClientId:
         return indexForClient(row, column, m_x11Clients, s_x11ClientId);
     case s_x11UnmanagedId:
         return indexForClient(row, column, m_unmanageds, s_x11UnmanagedId);
     case s_waylandClientId:
-        return indexForClient(row, column, m_shellClients, s_waylandClientId);
+        return indexForClient(row, column, m_waylandClients, s_waylandClientId);
     case s_workspaceInternalId:
         return indexForClient(row, column, m_internalClients, s_workspaceInternalId);
     default:
         break;
     }
 
     // index for a property (third level)
     if (parent.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::x11Client);
     } else if (parent.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::unmanaged);
     } else if (parent.internalId() < s_idDistance * (s_waylandClientId + 1)) {
-        return indexForProperty(row, column, parent, &DebugConsoleModel::shellClient);
+        return indexForProperty(row, column, parent, &DebugConsoleModel::waylandClient);
     } else if (parent.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::internalClient);
     }
 
     return QModelIndex();
 }
 
 QModelIndex DebugConsoleModel::parent(const QModelIndex &child) const
 {
     if (child.internalId() <= s_workspaceInternalId) {
         return QModelIndex();
     }
     if (child.internalId() & s_propertyBitMask) {
         // a property
         const quint32 parentId = child.internalId() & s_clientBitMask;
         if (parentId < s_idDistance * (s_x11ClientId + 1)) {
             return createIndex(parentId - (s_idDistance * s_x11ClientId), 0, parentId);
         } else if (parentId < s_idDistance * (s_x11UnmanagedId + 1)) {
             return createIndex(parentId - (s_idDistance * s_x11UnmanagedId), 0, parentId);
         } else if (parentId < s_idDistance * (s_waylandClientId + 1)) {
             return createIndex(parentId - (s_idDistance * s_waylandClientId), 0, parentId);
         } else if (parentId < s_idDistance * (s_workspaceInternalId + 1)) {
             return createIndex(parentId - (s_idDistance * s_workspaceInternalId), 0, parentId);
         }
         return QModelIndex();
     }
     if (child.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return createIndex(s_x11ClientId -1, 0, s_x11ClientId);
     } else if (child.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return createIndex(s_x11UnmanagedId -1, 0, s_x11UnmanagedId);
     } else if (child.internalId() < s_idDistance * (s_waylandClientId + 1)) {
         return createIndex(s_waylandClientId -1, 0, s_waylandClientId);
     } else if (child.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return createIndex(s_workspaceInternalId -1, 0, s_workspaceInternalId);
     }
     return QModelIndex();
 }
 
 QVariant DebugConsoleModel::propertyData(QObject *object, const QModelIndex &index, int role) const
 {
     Q_UNUSED(role)
     const auto property = object->metaObject()->property(index.row());
     if (index.column() == 0) {
         return property.name();
     } else {
         const QVariant value = property.read(object);
         if (qstrcmp(property.name(), "windowType") == 0) {
             switch (value.toInt()) {
             case NET::Normal:
                 return QStringLiteral("NET::Normal");
             case NET::Desktop:
                 return QStringLiteral("NET::Desktop");
             case NET::Dock:
                 return QStringLiteral("NET::Dock");
             case NET::Toolbar:
                 return QStringLiteral("NET::Toolbar");
             case NET::Menu:
                 return QStringLiteral("NET::Menu");
             case NET::Dialog:
                 return QStringLiteral("NET::Dialog");
             case NET::Override:
                 return QStringLiteral("NET::Override");
             case NET::TopMenu:
                 return QStringLiteral("NET::TopMenu");
             case NET::Utility:
                 return QStringLiteral("NET::Utility");
             case NET::Splash:
                 return QStringLiteral("NET::Splash");
             case NET::DropdownMenu:
                 return QStringLiteral("NET::DropdownMenu");
             case NET::PopupMenu:
                 return QStringLiteral("NET::PopupMenu");
             case NET::Tooltip:
                 return QStringLiteral("NET::Tooltip");
             case NET::Notification:
                 return QStringLiteral("NET::Notification");
             case NET::ComboBox:
                 return QStringLiteral("NET::ComboBox");
             case NET::DNDIcon:
                 return QStringLiteral("NET::DNDIcon");
             case NET::OnScreenDisplay:
                 return QStringLiteral("NET::OnScreenDisplay");
             case NET::CriticalNotification:
                 return QStringLiteral("NET::CriticalNotification");
             case NET::Unknown:
             default:
                 return QStringLiteral("NET::Unknown");
             }
         }
         return value;
     }
     return QVariant();
 }
 
 template <class T>
 QVariant DebugConsoleModel::clientData(const QModelIndex &index, int role, const QVector<T*> clients) const
 {
     if (index.row() >= clients.count()) {
         return QVariant();
     }
     auto c = clients.at(index.row());
     if (role == Qt::DisplayRole) {
         return QStringLiteral("%1: %2").arg(c->window()).arg(c->caption());
     } else if (role == Qt::DecorationRole) {
         return c->icon();
     }
     return QVariant();
 }
 
 QVariant DebugConsoleModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     if (!index.parent().isValid()) {
         // one of the top levels
         if (index.column() != 0 || role != Qt::DisplayRole) {
             return QVariant();
         }
         switch (index.internalId()) {
         case s_x11ClientId:
             return i18n("X11 Client Windows");
         case s_x11UnmanagedId:
             return i18n("X11 Unmanaged Windows");
         case s_waylandClientId:
             return i18n("Wayland Windows");
         case s_workspaceInternalId:
             return i18n("Internal Windows");
         default:
             return QVariant();
         }
     }
     if (index.internalId() & s_propertyBitMask) {
         if (index.column() >= 2 || role != Qt::DisplayRole) {
             return QVariant();
         }
-        if (XdgShellClient *c = shellClient(index)) {
+        if (AbstractClient *c = waylandClient(index)) {
             return propertyData(c, index, role);
         } else if (InternalClient *c = internalClient(index)) {
             return propertyData(c, index, role);
         } else if (X11Client *c = x11Client(index)) {
             return propertyData(c, index, role);
         } else if (Unmanaged *u = unmanaged(index)) {
             return propertyData(u, index, role);
         }
     } else {
         if (index.column() != 0) {
             return QVariant();
         }
         switch (index.parent().internalId()) {
         case s_x11ClientId:
             return clientData(index, role, m_x11Clients);
         case s_x11UnmanagedId: {
             if (index.row() >= m_unmanageds.count()) {
                 return QVariant();
             }
             auto u = m_unmanageds.at(index.row());
             if (role == Qt::DisplayRole) {
                 return u->window();
             }
             break;
         }
         case s_waylandClientId:
-            return clientData(index, role, m_shellClients);
+            return clientData(index, role, m_waylandClients);
         case s_workspaceInternalId:
             return clientData(index, role, m_internalClients);
         default:
             break;
         }
     }
 
     return QVariant();
 }
 
 template<class T>
 static T *clientForIndex(const QModelIndex &index, const QVector<T*> &clients, int id)
 {
     const qint32 row = (index.internalId() & s_clientBitMask) - (s_idDistance * id);
     if (row < 0 || row >= clients.count()) {
         return nullptr;
     }
     return clients.at(row);
 }
 
-XdgShellClient *DebugConsoleModel::shellClient(const QModelIndex &index) const
+AbstractClient *DebugConsoleModel::waylandClient(const QModelIndex &index) const
 {
-    return clientForIndex(index, m_shellClients, s_waylandClientId);
+    return clientForIndex(index, m_waylandClients, s_waylandClientId);
 }
 
 InternalClient *DebugConsoleModel::internalClient(const QModelIndex &index) const
 {
     return clientForIndex(index, m_internalClients, s_workspaceInternalId);
 }
 
 X11Client *DebugConsoleModel::x11Client(const QModelIndex &index) const
 {
     return clientForIndex(index, m_x11Clients, s_x11ClientId);
 }
 
 Unmanaged *DebugConsoleModel::unmanaged(const QModelIndex &index) const
 {
     return clientForIndex(index, m_unmanageds, s_x11UnmanagedId);
 }
 
 /////////////////////////////////////// SurfaceTreeModel
 SurfaceTreeModel::SurfaceTreeModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
     // TODO: it would be nice to not have to reset the model on each change
     auto reset = [this] {
         beginResetModel();
         endResetModel();
     };
     using namespace KWayland::Server;
 
     const auto unmangeds = workspace()->unmanagedList();
     for (auto u : unmangeds) {
         if (!u->surface()) {
             continue;
         }
         connect(u->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     for (auto c : workspace()->allClientList()) {
         if (!c->surface()) {
             continue;
         }
         connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     for (auto c : workspace()->desktopList()) {
         if (!c->surface()) {
             continue;
         }
         connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     if (waylandServer()) {
         connect(waylandServer(), &WaylandServer::shellClientAdded, this,
-            [this, reset] (XdgShellClient *c) {
+            [this, reset] (AbstractClient *c) {
                 connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
                 reset();
             }
         );
     }
     connect(workspace(), &Workspace::clientAdded, this,
         [this, reset] (AbstractClient *c) {
             if (c->surface()) {
                 connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
             }
             reset();
         }
     );
     connect(workspace(), &Workspace::clientRemoved, this, reset);
     connect(workspace(), &Workspace::unmanagedAdded, this,
         [this, reset] (Unmanaged *u) {
             if (u->surface()) {
                 connect(u->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
             }
             reset();
         }
     );
     connect(workspace(), &Workspace::unmanagedRemoved, this, reset);
 }
 
 SurfaceTreeModel::~SurfaceTreeModel() = default;
 
 int SurfaceTreeModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 int SurfaceTreeModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         using namespace KWayland::Server;
         if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(parent.internalPointer())) {
             const auto &children = surface->childSubSurfaces();
             return children.count();
         }
         return 0;
     }
     // toplevel are all windows
     return workspace()->allClientList().count() +
            workspace()->desktopList().count() +
            workspace()->unmanagedList().count();
 }
 
 QModelIndex SurfaceTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (column != 0) {
         // invalid column
         return QModelIndex();
     }
 
     if (parent.isValid()) {
         using namespace KWayland::Server;
         if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(parent.internalPointer())) {
             const auto &children = surface->childSubSurfaces();
             if (row < children.count()) {
                 return createIndex(row, column, children.at(row)->surface().data());
             }
         }
         return QModelIndex();
     }
     // a window
     const auto &allClients = workspace()->allClientList();
     if (row < allClients.count()) {
         // references a client
         return createIndex(row, column, allClients.at(row)->surface());
     }
     int reference = allClients.count();
     const auto &desktopClients = workspace()->desktopList();
     if (row < reference + desktopClients.count()) {
         return createIndex(row, column, desktopClients.at(row-reference)->surface());
     }
     reference += desktopClients.count();
     const auto &unmanaged = workspace()->unmanagedList();
     if (row < reference + unmanaged.count()) {
         return createIndex(row, column, unmanaged.at(row-reference)->surface());
     }
     reference += unmanaged.count();
     // not found
     return QModelIndex();
 }
 
 QModelIndex SurfaceTreeModel::parent(const QModelIndex &child) const
 {
     using namespace KWayland::Server;
     if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(child.internalPointer())) {
         const auto &subsurface = surface->subSurface();
         if (subsurface.isNull()) {
             // doesn't reference a subsurface, this is a top-level window
             return QModelIndex();
         }
         SurfaceInterface *parent = subsurface->parentSurface().data();
         if (!parent) {
             // something is wrong
             return QModelIndex();
         }
         // is the parent a subsurface itself?
         if (parent->subSurface()) {
             auto grandParent = parent->subSurface()->parentSurface();
             if (grandParent.isNull()) {
                 // something is wrong
                 return QModelIndex();
             }
             const auto &children = grandParent->childSubSurfaces();
             for (int row = 0; row < children.count(); row++) {
                 if (children.at(row).data() == parent->subSurface().data()) {
                     return createIndex(row, 0, parent);
                 }
             }
             return QModelIndex();
         }
         // not a subsurface, thus it's a true window
         int row = 0;
         const auto &allClients = workspace()->allClientList();
         for (; row < allClients.count(); row++) {
             if (allClients.at(row)->surface() == parent) {
                 return createIndex(row, 0, parent);
             }
         }
         row = allClients.count();
         const auto &desktopClients = workspace()->desktopList();
         for (int i = 0; i < desktopClients.count(); i++) {
             if (desktopClients.at(i)->surface() == parent) {
                 return createIndex(row + i, 0, parent);
             }
         }
         row += desktopClients.count();
         const auto &unmanaged = workspace()->unmanagedList();
         for (int i = 0; i < unmanaged.count(); i++) {
             if (unmanaged.at(i)->surface() == parent) {
                 return createIndex(row + i, 0, parent);
             }
         }
         row += unmanaged.count();
     }
     return QModelIndex();
 }
 
 QVariant SurfaceTreeModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     using namespace KWayland::Server;
     if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(index.internalPointer())) {
         if (role == Qt::DisplayRole || role == Qt::ToolTipRole) {
             return QStringLiteral("%1 (%2) - %3").arg(surface->client()->executablePath())
                                                 .arg(surface->client()->processId())
                                                 .arg(surface->id());
         } else if (role == Qt::DecorationRole) {
             if (auto buffer = surface->buffer()) {
                 if (buffer->shmBuffer()) {
                     return buffer->data().scaled(QSize(64, 64), Qt::KeepAspectRatio);
                 }
             }
         }
     }
     return QVariant();
 }
 
 InputDeviceModel::InputDeviceModel(QObject *parent)
     : QAbstractItemModel(parent)
     , m_devices(LibInput::Connection::self()->devices())
 {
     for (auto it = m_devices.constBegin(); it != m_devices.constEnd(); ++it) {
         setupDeviceConnections(*it);
     }
     auto c = LibInput::Connection::self();
     connect(c, &LibInput::Connection::deviceAdded, this,
         [this] (LibInput::Device *d) {
             beginInsertRows(QModelIndex(), m_devices.count(), m_devices.count());
             m_devices << d;
             setupDeviceConnections(d);
             endInsertRows();
         }
     );
     connect(c, &LibInput::Connection::deviceRemoved, this,
         [this] (LibInput::Device *d) {
             const int index = m_devices.indexOf(d);
             if (index == -1) {
                 return;
             }
             beginRemoveRows(QModelIndex(), index, index);
             m_devices.removeAt(index);
             endRemoveRows();
         }
     );
 }
 
 InputDeviceModel::~InputDeviceModel() = default;
 
 
 int InputDeviceModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 2;
 }
 
 QVariant InputDeviceModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     if (!index.parent().isValid() && index.column() == 0) {
         const auto devices = LibInput::Connection::self()->devices();
         if (index.row() >= devices.count()) {
             return QVariant();
         }
         if (role == Qt::DisplayRole) {
             return devices.at(index.row())->name();
         }
     }
     if (index.parent().isValid()) {
         if (role == Qt::DisplayRole) {
             const auto device = LibInput::Connection::self()->devices().at(index.parent().row());
             const auto property = device->metaObject()->property(index.row());
             if (index.column() == 0) {
                 return property.name();
             } else if (index.column() == 1) {
                 return device->property(property.name());
             }
         }
     }
     return QVariant();
 }
 
 QModelIndex InputDeviceModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (column >= 2) {
         return QModelIndex();
     }
     if (parent.isValid()) {
         if (parent.internalId() & s_propertyBitMask) {
             return QModelIndex();
         }
         if (row >= LibInput::Connection::self()->devices().at(parent.row())->metaObject()->propertyCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, quint32(row + 1) << 16 | parent.internalId());
     }
     if (row >= LibInput::Connection::self()->devices().count()) {
         return QModelIndex();
     }
     return createIndex(row, column, row + 1);
 }
 
 int InputDeviceModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return LibInput::Connection::self()->devices().count();
     }
     if (parent.internalId() & s_propertyBitMask) {
         return 0;
     }
 
     return LibInput::Connection::self()->devices().at(parent.row())->metaObject()->propertyCount();
 }
 
 QModelIndex InputDeviceModel::parent(const QModelIndex &child) const
 {
     if (child.internalId() & s_propertyBitMask) {
         const quintptr parentId = child.internalId() & s_clientBitMask;
         return createIndex(parentId - 1, 0, parentId);
     }
     return QModelIndex();
 }
 
 void InputDeviceModel::setupDeviceConnections(LibInput::Device *device)
 {
     connect(device, &LibInput::Device::enabledChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("enabled"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
     connect(device, &LibInput::Device::leftHandedChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("leftHanded"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
     connect(device, &LibInput::Device::pointerAccelerationChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("pointerAcceleration"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
 }
 
 }
diff --git a/debug_console.h b/debug_console.h
index 1ad925a24..29f61b171 100644
--- a/debug_console.h
+++ b/debug_console.h
@@ -1,191 +1,191 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_DEBUG_CONSOLE_H
 #define KWIN_DEBUG_CONSOLE_H
 
 #include <kwin_export.h>
 #include <config-kwin.h>
 #include "input.h"
 #include "input_event_spy.h"
 
 #include <QAbstractItemModel>
 #include <QStyledItemDelegate>
 #include <QVector>
 
 class QTextEdit;
 
 namespace Ui
 {
 class DebugConsole;
 }
 
 namespace KWin
 {
 
+class AbstractClient;
 class X11Client;
 class InternalClient;
-class XdgShellClient;
 class Unmanaged;
 class DebugConsoleFilter;
 
 class KWIN_EXPORT DebugConsoleModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit DebugConsoleModel(QObject *parent = nullptr);
     ~DebugConsoleModel() override;
 
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 
 private:
     template <class T>
     QModelIndex indexForClient(int row, int column, const QVector<T*> &clients, int id) const;
     template <class T>
     QModelIndex indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const;
     template <class T>
     int propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const;
     QVariant propertyData(QObject *object, const QModelIndex &index, int role) const;
     template <class T>
     QVariant clientData(const QModelIndex &index, int role, const QVector<T*> clients) const;
     template <class T>
     void add(int parentRow, QVector<T*> &clients, T *client);
     template <class T>
     void remove(int parentRow, QVector<T*> &clients, T *client);
-    XdgShellClient *shellClient(const QModelIndex &index) const;
+    AbstractClient *waylandClient(const QModelIndex &index) const;
     InternalClient *internalClient(const QModelIndex &index) const;
     X11Client *x11Client(const QModelIndex &index) const;
     Unmanaged *unmanaged(const QModelIndex &index) const;
     int topLevelRowCount() const;
 
-    QVector<XdgShellClient *> m_shellClients;
+    QVector<AbstractClient *> m_waylandClients;
     QVector<InternalClient*> m_internalClients;
     QVector<X11Client *> m_x11Clients;
     QVector<Unmanaged*> m_unmanageds;
 
 };
 
 class DebugConsoleDelegate : public QStyledItemDelegate
 {
     Q_OBJECT
 public:
     explicit DebugConsoleDelegate(QObject *parent = nullptr);
     ~DebugConsoleDelegate() override;
 
     QString displayText(const QVariant &value, const QLocale &locale) const override;
 };
 
 class KWIN_EXPORT DebugConsole : public QWidget
 {
     Q_OBJECT
 public:
     DebugConsole();
     ~DebugConsole() override;
 
 protected:
     void showEvent(QShowEvent *event) override;
 
 private:
     void initGLTab();
     void updateKeyboardTab();
 
     QScopedPointer<Ui::DebugConsole> m_ui;
     QScopedPointer<DebugConsoleFilter> m_inputFilter;
 };
 
 class SurfaceTreeModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit SurfaceTreeModel(QObject *parent = nullptr);
     ~SurfaceTreeModel() override;
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 };
 
 class DebugConsoleFilter : public InputEventSpy
 {
 public:
     explicit DebugConsoleFilter(QTextEdit *textEdit);
     ~DebugConsoleFilter() override;
 
     void pointerEvent(MouseEvent *event) override;
     void wheelEvent(WheelEvent *event) override;
     void keyEvent(KeyEvent *event) override;
     void touchDown(qint32 id, const QPointF &pos, quint32 time) override;
     void touchMotion(qint32 id, const QPointF &pos, quint32 time) override;
     void touchUp(qint32 id, quint32 time) override;
 
     void pinchGestureBegin(int fingerCount, quint32 time) override;
     void pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override;
     void pinchGestureEnd(quint32 time) override;
     void pinchGestureCancelled(quint32 time) override;
 
     void swipeGestureBegin(int fingerCount, quint32 time) override;
     void swipeGestureUpdate(const QSizeF &delta, quint32 time) override;
     void swipeGestureEnd(quint32 time) override;
     void swipeGestureCancelled(quint32 time) override;
 
     void switchEvent(SwitchEvent *event) override;
 
     void tabletToolEvent(QTabletEvent *event) override;
     void tabletToolButtonEvent(const QSet<uint> &pressedButtons) override;
     void tabletPadButtonEvent(const QSet<uint> &pressedButtons) override;
     void tabletPadStripEvent(int number, int position, bool isFinger) override;
     void tabletPadRingEvent(int number, int position, bool isFinger) override;
 
 private:
     QTextEdit *m_textEdit;
 };
 
 namespace LibInput
 {
 class Device;
 }
 
 class InputDeviceModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit InputDeviceModel(QObject *parent = nullptr);
     ~InputDeviceModel() override;
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 
 private:
     void setupDeviceConnections(LibInput::Device *device);
     QVector<LibInput::Device*> m_devices;
 };
 
 }
 
 #endif
diff --git a/effects.cpp b/effects.cpp
index 730e9a15d..9deaac1c1 100644
--- a/effects.cpp
+++ b/effects.cpp
@@ -1,2423 +1,2421 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "effects.h"
 
 #include "effectsadaptor.h"
 #include "effectloader.h"
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "deleted.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "group.h"
 #include "internal_client.h"
 #include "osd.h"
 #include "pointer_input.h"
 #include "unmanaged.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "scripting/scriptedeffect.h"
 #include "screens.h"
 #include "screenlockerwatcher.h"
 #include "thumbnailitem.h"
 #include "virtualdesktops.h"
 #include "window_property_notify_x11_filter.h"
 #include "workspace.h"
 #include "kwinglutils.h"
 #include "kwineffectquickview.h"
 
 #include <QDebug>
 
 #include <Plasma/Theme>
 
 #include "composite.h"
 #include "xcbutils.h"
 #include "platform.h"
 #include "xdgshellclient.h"
 #include "wayland_server.h"
 
 #include "decorations/decorationbridge.h"
 #include <KDecoration2/DecorationSettings>
 
 namespace KWin
 {
 //---------------------
 // Static
 
 static QByteArray readWindowProperty(xcb_window_t win, xcb_atom_t atom, xcb_atom_t type, int format)
 {
     if (win == XCB_WINDOW_NONE) {
         return QByteArray();
     }
     uint32_t len = 32768;
     for (;;) {
         Xcb::Property prop(false, win, atom, XCB_ATOM_ANY, 0, len);
         if (prop.isNull()) {
             // get property failed
             return QByteArray();
         }
         if (prop->bytes_after > 0) {
             len *= 2;
             continue;
         }
         return prop.toByteArray(format, type);
     }
 }
 
 static void deleteWindowProperty(Window win, long int atom)
 {
     if (win == XCB_WINDOW_NONE) {
         return;
     }
     xcb_delete_property(kwinApp()->x11Connection(), win, atom);
 }
 
 static xcb_atom_t registerSupportProperty(const QByteArray &propertyName)
 {
     auto c = kwinApp()->x11Connection();
     if (!c) {
         return XCB_ATOM_NONE;
     }
     // get the atom for the propertyName
     ScopedCPointer<xcb_intern_atom_reply_t> atomReply(xcb_intern_atom_reply(c,
         xcb_intern_atom_unchecked(c, false, propertyName.size(), propertyName.constData()),
         nullptr));
     if (atomReply.isNull()) {
         return XCB_ATOM_NONE;
     }
     // announce property on root window
     unsigned char dummy = 0;
     xcb_change_property(c, XCB_PROP_MODE_REPLACE, kwinApp()->x11RootWindow(), atomReply->atom, atomReply->atom, 8, 1, &dummy);
     // TODO: add to _NET_SUPPORTED
     return atomReply->atom;
 }
 
 //---------------------
 
 EffectsHandlerImpl::EffectsHandlerImpl(Compositor *compositor, Scene *scene)
     : EffectsHandler(scene->compositingType())
     , keyboard_grab_effect(nullptr)
     , fullscreen_effect(nullptr)
     , next_window_quad_type(EFFECT_QUAD_TYPE_START)
     , m_compositor(compositor)
     , m_scene(scene)
     , m_desktopRendering(false)
     , m_currentRenderedDesktop(0)
     , m_effectLoader(new EffectLoader(this))
     , m_trackingCursorChanges(0)
 {
     qRegisterMetaType<QVector<KWin::EffectWindow*>>();
     connect(m_effectLoader, &AbstractEffectLoader::effectLoaded, this,
         [this](Effect *effect, const QString &name) {
             effect_order.insert(effect->requestedEffectChainPosition(), EffectPair(name, effect));
             loaded_effects << EffectPair(name, effect);
             effectsChanged();
         }
     );
     m_effectLoader->setConfig(kwinApp()->config());
     new EffectsAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Effects"), this);
     // init is important, otherwise causes crashes when quads are build before the first painting pass start
     m_currentBuildQuadsIterator = m_activeEffects.constEnd();
 
     Workspace *ws = Workspace::self();
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(ws, &Workspace::showingDesktopChanged,
             this, &EffectsHandlerImpl::showingDesktopChanged);
     connect(ws, &Workspace::currentDesktopChanged, this,
         [this](int old, AbstractClient *c) {
             const int newDesktop = VirtualDesktopManager::self()->current();
             if (old != 0 && newDesktop != old) {
                 emit desktopChanged(old, newDesktop, c ? c->effectWindow() : nullptr);
                 // TODO: remove in 4.10
                 emit desktopChanged(old, newDesktop);
             }
         }
     );
     connect(ws, &Workspace::desktopPresenceChanged, this,
         [this](AbstractClient *c, int old) {
             if (!c->effectWindow()) {
                 return;
             }
             emit desktopPresenceChanged(c->effectWindow(), old, c->desktop());
         }
     );
     connect(ws, &Workspace::clientAdded, this,
         [this](X11Client *c) {
             if (c->readyForPainting())
                 slotClientShown(c);
             else
                 connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
         }
     );
     connect(ws, &Workspace::unmanagedAdded, this,
         [this](Unmanaged *u) {
             // it's never initially ready but has synthetic 50ms delay
             connect(u, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotUnmanagedShown);
         }
     );
     connect(ws, &Workspace::internalClientAdded, this,
         [this](InternalClient *client) {
             setupAbstractClientConnections(client);
             emit windowAdded(client->effectWindow());
         }
     );
     connect(ws, &Workspace::clientActivated, this,
         [this](KWin::AbstractClient *c) {
             emit windowActivated(c ? c->effectWindow() : nullptr);
         }
     );
     connect(ws, &Workspace::deletedRemoved, this,
         [this](KWin::Deleted *d) {
             emit windowDeleted(d->effectWindow());
             elevated_windows.removeAll(d->effectWindow());
         }
     );
     connect(ws->sessionManager(), &SessionManager::stateChanged, this,
             &KWin::EffectsHandler::sessionStateChanged);
     connect(vds, &VirtualDesktopManager::countChanged, this, &EffectsHandler::numberDesktopsChanged);
     connect(Cursor::self(), &Cursor::mouseChanged, this, &EffectsHandler::mouseChanged);
     connect(screens(), &Screens::countChanged,    this, &EffectsHandler::numberScreensChanged);
     connect(screens(), &Screens::sizeChanged,     this, &EffectsHandler::virtualScreenSizeChanged);
     connect(screens(), &Screens::geometryChanged, this, &EffectsHandler::virtualScreenGeometryChanged);
 #ifdef KWIN_BUILD_ACTIVITIES
     if (Activities *activities = Activities::self()) {
         connect(activities, &Activities::added,          this, &EffectsHandler::activityAdded);
         connect(activities, &Activities::removed,        this, &EffectsHandler::activityRemoved);
         connect(activities, &Activities::currentChanged, this, &EffectsHandler::currentActivityChanged);
     }
 #endif
     connect(ws, &Workspace::stackingOrderChanged, this, &EffectsHandler::stackingOrderChanged);
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     connect(tabBox, &TabBox::TabBox::tabBoxAdded,    this, &EffectsHandler::tabBoxAdded);
     connect(tabBox, &TabBox::TabBox::tabBoxUpdated,  this, &EffectsHandler::tabBoxUpdated);
     connect(tabBox, &TabBox::TabBox::tabBoxClosed,   this, &EffectsHandler::tabBoxClosed);
     connect(tabBox, &TabBox::TabBox::tabBoxKeyEvent, this, &EffectsHandler::tabBoxKeyEvent);
 #endif
     connect(ScreenEdges::self(), &ScreenEdges::approaching, this, &EffectsHandler::screenEdgeApproaching);
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked, this, &EffectsHandler::screenLockingChanged);
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::aboutToLock, this, &EffectsHandler::screenAboutToLock);
 
     connect(kwinApp(), &Application::x11ConnectionChanged, this,
         [this] {
             registered_atoms.clear();
             for (auto it = m_propertiesForEffects.keyBegin(); it != m_propertiesForEffects.keyEnd(); it++) {
                 const auto atom = registerSupportProperty(*it);
                 if (atom == XCB_ATOM_NONE) {
                     continue;
                 }
                 m_compositor->keepSupportProperty(atom);
                 m_managedProperties.insert(*it, atom);
                 registerPropertyType(atom, true);
             }
             if (kwinApp()->x11Connection()) {
                 m_x11WindowPropertyNotify = std::make_unique<WindowPropertyNotifyX11Filter>(this);
             } else {
                 m_x11WindowPropertyNotify.reset();
             }
             emit xcbConnectionChanged();
         }
     );
 
     if (kwinApp()->x11Connection()) {
         m_x11WindowPropertyNotify = std::make_unique<WindowPropertyNotifyX11Filter>(this);
     }
 
     // connect all clients
     for (X11Client *c : ws->clientList()) {
         setupClientConnections(c);
     }
     for (Unmanaged *u : ws->unmanagedList()) {
         setupUnmanagedConnections(u);
     }
     for (InternalClient *client : ws->internalClients()) {
         setupAbstractClientConnections(client);
     }
     if (auto w = waylandServer()) {
-        connect(w, &WaylandServer::shellClientAdded, this,
-            [this](XdgShellClient *c) {
-                if (c->readyForPainting())
-                    slotXdgShellClientShown(c);
-                else
-                    connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotXdgShellClientShown);
-            }
-        );
+        connect(w, &WaylandServer::shellClientAdded, this, [this](AbstractClient *c) {
+            if (c->readyForPainting())
+                slotWaylandClientShown(c);
+            else
+                connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotWaylandClientShown);
+        });
         const auto clients = waylandServer()->clients();
-        for (XdgShellClient *c : clients) {
+        for (AbstractClient *c : clients) {
             if (c->readyForPainting()) {
                 setupAbstractClientConnections(c);
             } else {
-                connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotXdgShellClientShown);
+                connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotWaylandClientShown);
             }
         }
     }
     reconfigure();
 }
 
 EffectsHandlerImpl::~EffectsHandlerImpl()
 {
     unloadAllEffects();
 }
 
 void EffectsHandlerImpl::unloadAllEffects()
 {
     for (const EffectPair &pair : loaded_effects) {
         destroyEffect(pair.second);
     }
 
     effect_order.clear();
     m_effectLoader->clear();
 
     effectsChanged();
 }
 
 void EffectsHandlerImpl::setupAbstractClientConnections(AbstractClient* c)
 {
     connect(c, &AbstractClient::windowClosed, this, &EffectsHandlerImpl::slotWindowClosed);
     connect(c, static_cast<void (AbstractClient::*)(KWin::AbstractClient*, MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged),
             this, &EffectsHandlerImpl::slotClientMaximized);
     connect(c, &AbstractClient::clientStartUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowStartUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::clientStepUserMovedResized, this,
         [this](AbstractClient *c, const QRect &geometry) {
             emit windowStepUserMovedResized(c->effectWindow(), geometry);
         }
     );
     connect(c, &AbstractClient::clientFinishUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowFinishUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::opacityChanged, this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(c, &AbstractClient::clientMinimized, this,
         [this](AbstractClient *c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowMinimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::clientUnminimized, this,
         [this](AbstractClient* c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowUnminimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::modalChanged,         this, &EffectsHandlerImpl::slotClientModalityChanged);
     connect(c, &AbstractClient::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(c, &AbstractClient::frameGeometryChanged, this, &EffectsHandlerImpl::slotFrameGeometryChanged);
     connect(c, &AbstractClient::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
     connect(c, &AbstractClient::unresponsiveChanged, this,
         [this, c](bool unresponsive) {
             emit windowUnresponsiveChanged(c->effectWindow(), unresponsive);
         }
     );
     connect(c, &AbstractClient::windowShown, this,
         [this](Toplevel *c) {
             emit windowShown(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::windowHidden, this,
         [this](Toplevel *c) {
             emit windowHidden(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::keepAboveChanged, this,
         [this, c](bool above) {
             Q_UNUSED(above)
             emit windowKeepAboveChanged(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::keepBelowChanged, this,
         [this, c](bool below) {
             Q_UNUSED(below)
             emit windowKeepBelowChanged(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::fullScreenChanged, this,
         [this, c]() {
             emit windowFullScreenChanged(c->effectWindow());
         }
     );
 }
 
 void EffectsHandlerImpl::setupClientConnections(X11Client *c)
 {
     setupAbstractClientConnections(c);
     connect(c, &X11Client::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
 }
 
 void EffectsHandlerImpl::setupUnmanagedConnections(Unmanaged* u)
 {
     connect(u, &Unmanaged::windowClosed,         this, &EffectsHandlerImpl::slotWindowClosed);
     connect(u, &Unmanaged::opacityChanged,       this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(u, &Unmanaged::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(u, &Unmanaged::frameGeometryChanged, this, &EffectsHandlerImpl::slotFrameGeometryChanged);
     connect(u, &Unmanaged::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
     connect(u, &Unmanaged::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
 }
 
 void EffectsHandlerImpl::reconfigure()
 {
     m_effectLoader->queryAndLoadAll();
 }
 
 // the idea is that effects call this function again which calls the next one
 void EffectsHandlerImpl::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->prePaintScreen(data, time);
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->paintScreen(mask, region, data);
         --m_currentPaintScreenIterator;
     } else
         m_scene->finalPaintScreen(mask, region, data);
 }
 
 void EffectsHandlerImpl::paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData &data)
 {
     if (desktop < 1 || desktop > numberOfDesktops()) {
         return;
     }
     m_currentRenderedDesktop = desktop;
     m_desktopRendering = true;
     // save the paint screen iterator
     EffectsIterator savedIterator = m_currentPaintScreenIterator;
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     effects->paintScreen(mask, region, data);
     // restore the saved iterator
     m_currentPaintScreenIterator = savedIterator;
     m_desktopRendering = false;
 }
 
 void EffectsHandlerImpl::postPaintScreen()
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->postPaintScreen();
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->prePaintWindow(w, data, time);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->paintWindow(w, mask, region, data);
         --m_currentPaintWindowIterator;
     } else
         m_scene->finalPaintWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity)
 {
     if (m_currentPaintEffectFrameIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintEffectFrameIterator++)->paintEffectFrame(frame, region, opacity, frameOpacity);
         --m_currentPaintEffectFrameIterator;
     } else {
         const EffectFrameImpl* frameImpl = static_cast<const EffectFrameImpl*>(frame);
         frameImpl->finalRender(region, opacity, frameOpacity);
     }
 }
 
 void EffectsHandlerImpl::postPaintWindow(EffectWindow* w)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->postPaintWindow(w);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 Effect *EffectsHandlerImpl::provides(Effect::Feature ef)
 {
     for (int i = 0; i < loaded_effects.size(); ++i)
         if (loaded_effects.at(i).second->provides(ef))
             return loaded_effects.at(i).second;
     return nullptr;
 }
 
 void EffectsHandlerImpl::drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (m_currentDrawWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentDrawWindowIterator++)->drawWindow(w, mask, region, data);
         --m_currentDrawWindowIterator;
     } else
         m_scene->finalDrawWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::buildQuads(EffectWindow* w, WindowQuadList& quadList)
 {
     static bool initIterator = true;
     if (initIterator) {
         m_currentBuildQuadsIterator = m_activeEffects.constBegin();
         initIterator = false;
     }
     if (m_currentBuildQuadsIterator != m_activeEffects.constEnd()) {
         (*m_currentBuildQuadsIterator++)->buildQuads(w, quadList);
         --m_currentBuildQuadsIterator;
     }
     if (m_currentBuildQuadsIterator == m_activeEffects.constBegin())
         initIterator = true;
 }
 
 bool EffectsHandlerImpl::hasDecorationShadows() const
 {
     return false;
 }
 
 bool EffectsHandlerImpl::decorationsHaveAlpha() const
 {
     return true;
 }
 
 bool EffectsHandlerImpl::decorationSupportsBlurBehind() const
 {
     return Decoration::DecorationBridge::self()->needsBlur();
 }
 
 // start another painting pass
 void EffectsHandlerImpl::startPaint()
 {
     m_activeEffects.clear();
     m_activeEffects.reserve(loaded_effects.count());
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->isActive()) {
             m_activeEffects << it->second;
         }
     }
     m_currentDrawWindowIterator = m_activeEffects.constBegin();
     m_currentPaintWindowIterator = m_activeEffects.constBegin();
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     m_currentPaintEffectFrameIterator = m_activeEffects.constBegin();
 }
 
 void EffectsHandlerImpl::slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode)
 {
     bool horizontal = false;
     bool vertical = false;
     switch (maxMode) {
     case MaximizeHorizontal:
         horizontal = true;
         break;
     case MaximizeVertical:
         vertical = true;
         break;
     case MaximizeFull:
         horizontal = true;
         vertical = true;
         break;
     case MaximizeRestore: // fall through
     default:
         // default - nothing to do
         break;
     }
     if (EffectWindowImpl *w = c->effectWindow()) {
         emit windowMaximizedStateChanged(w, horizontal, vertical);
     }
 }
 
 void EffectsHandlerImpl::slotOpacityChanged(Toplevel *t, qreal oldOpacity)
 {
     if (t->opacity() == oldOpacity || !t->effectWindow()) {
         return;
     }
     emit windowOpacityChanged(t->effectWindow(), oldOpacity, (qreal)t->opacity());
 }
 
 void EffectsHandlerImpl::slotClientShown(KWin::Toplevel *t)
 {
     Q_ASSERT(qobject_cast<X11Client *>(t));
     X11Client *c = static_cast<X11Client *>(t);
     disconnect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
     setupClientConnections(c);
     emit windowAdded(c->effectWindow());
 }
 
-void EffectsHandlerImpl::slotXdgShellClientShown(Toplevel *t)
+void EffectsHandlerImpl::slotWaylandClientShown(Toplevel *toplevel)
 {
-    XdgShellClient *c = static_cast<XdgShellClient *>(t);
-    setupAbstractClientConnections(c);
-    emit windowAdded(t->effectWindow());
+    AbstractClient *client = static_cast<AbstractClient *>(toplevel);
+    setupAbstractClientConnections(client);
+    emit windowAdded(toplevel->effectWindow());
 }
 
 void EffectsHandlerImpl::slotUnmanagedShown(KWin::Toplevel *t)
 {   // regardless, unmanaged windows are -yet?- not synced anyway
     Q_ASSERT(qobject_cast<Unmanaged *>(t));
     Unmanaged *u = static_cast<Unmanaged*>(t);
     setupUnmanagedConnections(u);
     emit windowAdded(u->effectWindow());
 }
 
 void EffectsHandlerImpl::slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d)
 {
     c->disconnect(this);
     if (d) {
         emit windowClosed(c->effectWindow());
     }
 }
 
 void EffectsHandlerImpl::slotClientModalityChanged()
 {
     emit windowModalityChanged(static_cast<X11Client *>(sender())->effectWindow());
 }
 
 void EffectsHandlerImpl::slotCurrentTabAboutToChange(EffectWindow *from, EffectWindow *to)
 {
     emit currentTabAboutToChange(from, to);
 }
 
 void EffectsHandlerImpl::slotTabAdded(EffectWindow* w, EffectWindow* to)
 {
     emit tabAdded(w, to);
 }
 
 void EffectsHandlerImpl::slotTabRemoved(EffectWindow *w, EffectWindow* leaderOfFormerGroup)
 {
     emit tabRemoved(w, leaderOfFormerGroup);
 }
 
 void EffectsHandlerImpl::slotWindowDamaged(Toplevel* t, const QRect& r)
 {
     if (!t->effectWindow()) {
         // can happen during tear down of window
         return;
     }
     emit windowDamaged(t->effectWindow(), r);
 }
 
 void EffectsHandlerImpl::slotGeometryShapeChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == nullptr || t->effectWindow() == nullptr)
         return;
     emit windowGeometryShapeChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::slotFrameGeometryChanged(Toplevel *toplevel, const QRect &oldGeometry)
 {
     // effectWindow() might be nullptr during tear down of the client.
     if (toplevel->effectWindow()) {
         emit windowFrameGeometryChanged(toplevel->effectWindow(), oldGeometry);
     }
 }
 
 void EffectsHandlerImpl::slotPaddingChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == nullptr || t->effectWindow() == nullptr)
         return;
     emit windowPaddingChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::setActiveFullScreenEffect(Effect* e)
 {
     if (fullscreen_effect == e) {
         return;
     }
     const bool activeChanged = (e == nullptr || fullscreen_effect == nullptr);
     fullscreen_effect = e;
     emit activeFullScreenEffectChanged();
     if (activeChanged) {
         emit hasActiveFullScreenEffectChanged();
     }
 }
 
 Effect* EffectsHandlerImpl::activeFullScreenEffect() const
 {
     return fullscreen_effect;
 }
 
 bool EffectsHandlerImpl::hasActiveFullScreenEffect() const
 {
     return fullscreen_effect;
 }
 
 bool EffectsHandlerImpl::grabKeyboard(Effect* effect)
 {
     if (keyboard_grab_effect != nullptr)
         return false;
     if (!doGrabKeyboard()) {
         return false;
     }
     keyboard_grab_effect = effect;
     return true;
 }
 
 bool EffectsHandlerImpl::doGrabKeyboard()
 {
     return true;
 }
 
 void EffectsHandlerImpl::ungrabKeyboard()
 {
     Q_ASSERT(keyboard_grab_effect != nullptr);
     doUngrabKeyboard();
     keyboard_grab_effect = nullptr;
 }
 
 void EffectsHandlerImpl::doUngrabKeyboard()
 {
 }
 
 void EffectsHandlerImpl::grabbedKeyboardEvent(QKeyEvent* e)
 {
     if (keyboard_grab_effect != nullptr)
         keyboard_grab_effect->grabbedKeyboardEvent(e);
 }
 
 void EffectsHandlerImpl::startMouseInterception(Effect *effect, Qt::CursorShape shape)
 {
     if (m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.append(effect);
     if (m_grabbedMouseEffects.size() != 1) {
         return;
     }
     doStartMouseInterception(shape);
 }
 
 void EffectsHandlerImpl::doStartMouseInterception(Qt::CursorShape shape)
 {
     input()->pointer()->setEffectsOverrideCursor(shape);
 }
 
 void EffectsHandlerImpl::stopMouseInterception(Effect *effect)
 {
     if (!m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.removeAll(effect);
     if (m_grabbedMouseEffects.isEmpty()) {
         doStopMouseInterception();
     }
 }
 
 void EffectsHandlerImpl::doStopMouseInterception()
 {
     input()->pointer()->removeEffectsOverrideCursor();
 }
 
 bool EffectsHandlerImpl::isMouseInterception() const
 {
     return m_grabbedMouseEffects.count() > 0;
 }
 
 
 bool EffectsHandlerImpl::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchDown(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchMotion(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchUp(qint32 id, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchUp(id, time)) {
             return true;
         }
     }
     return false;
 }
 
 void EffectsHandlerImpl::registerGlobalShortcut(const QKeySequence &shortcut, QAction *action)
 {
     input()->registerShortcut(shortcut, action);
 }
 
 void EffectsHandlerImpl::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     input()->registerPointerShortcut(modifiers, pointerButtons, action);
 }
 
 void EffectsHandlerImpl::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     input()->registerAxisShortcut(modifiers, axis, action);
 }
 
 void EffectsHandlerImpl::registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action)
 {
     input()->registerTouchpadSwipeShortcut(direction, action);
 }
 
 void* EffectsHandlerImpl::getProxy(QString name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name)
             return (*it).second->proxy();
 
     return nullptr;
 }
 
 void EffectsHandlerImpl::startMousePolling()
 {
     if (Cursor::self())
         Cursor::self()->startMousePolling();
 }
 
 void EffectsHandlerImpl::stopMousePolling()
 {
     if (Cursor::self())
         Cursor::self()->stopMousePolling();
 }
 
 bool EffectsHandlerImpl::hasKeyboardGrab() const
 {
     return keyboard_grab_effect != nullptr;
 }
 
 void EffectsHandlerImpl::desktopResized(const QSize &size)
 {
     m_scene->screenGeometryChanged(size);
     emit screenGeometryChanged(size);
 }
 
 void EffectsHandlerImpl::registerPropertyType(long atom, bool reg)
 {
     if (reg)
         ++registered_atoms[ atom ]; // initialized to 0 if not present yet
     else {
         if (--registered_atoms[ atom ] == 0)
             registered_atoms.remove(atom);
     }
 }
 
 xcb_atom_t EffectsHandlerImpl::announceSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it != m_propertiesForEffects.end()) {
         // property has already been registered for an effect
         // just append Effect and return the atom stored in m_managedProperties
         if (!it.value().contains(effect)) {
             it.value().append(effect);
         }
         return m_managedProperties.value(propertyName, XCB_ATOM_NONE);
     }
     m_propertiesForEffects.insert(propertyName, QList<Effect*>() << effect);
     const auto atom = registerSupportProperty(propertyName);
     if (atom == XCB_ATOM_NONE) {
         return atom;
     }
     m_compositor->keepSupportProperty(atom);
     m_managedProperties.insert(propertyName, atom);
     registerPropertyType(atom, true);
     return atom;
 }
 
 void EffectsHandlerImpl::removeSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it == m_propertiesForEffects.end()) {
         // property is not registered - nothing to do
         return;
     }
     if (!it.value().contains(effect)) {
         // property is not registered for given effect - nothing to do
         return;
     }
     it.value().removeAll(effect);
     if (!it.value().isEmpty()) {
         // property still registered for another effect - nothing further to do
         return;
     }
     const xcb_atom_t atom = m_managedProperties.take(propertyName);
     registerPropertyType(atom, false);
     m_propertiesForEffects.remove(propertyName);
     m_compositor->removeSupportProperty(atom); // delayed removal
 }
 
 QByteArray EffectsHandlerImpl::readRootProperty(long atom, long type, int format) const
 {
     if (!kwinApp()->x11Connection()) {
         return QByteArray();
     }
     return readWindowProperty(kwinApp()->x11RootWindow(), atom, type, format);
 }
 
 void EffectsHandlerImpl::activateWindow(EffectWindow* c)
 {
     if (auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(c)->window())) {
         Workspace::self()->activateClient(cl, true);
     }
 }
 
 EffectWindow* EffectsHandlerImpl::activeWindow() const
 {
     return Workspace::self()->activeClient() ? Workspace::self()->activeClient()->effectWindow() : nullptr;
 }
 
 void EffectsHandlerImpl::moveWindow(EffectWindow* w, const QPoint& pos, bool snap, double snapAdjust)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (!cl || !cl->isMovable())
         return;
 
     if (snap)
         cl->move(Workspace::self()->adjustClientPosition(cl, pos, true, snapAdjust));
     else
         cl->move(pos);
 }
 
 void EffectsHandlerImpl::windowToDesktop(EffectWindow* w, int desktop)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock()) {
         Workspace::self()->sendClientToDesktop(cl, desktop, true);
     }
 }
 
 void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QVector<uint> &desktopIds)
 {
     AbstractClient* cl = qobject_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(w)->window());
     if (!cl || cl->isDesktop() || cl->isDock()) {
         return;
     }
     QVector<VirtualDesktop*> desktops;
     desktops.reserve(desktopIds.count());
     for (uint x11Id: desktopIds) {
         if (x11Id > VirtualDesktopManager::self()->count()) {
             continue;
         }
         VirtualDesktop *d = VirtualDesktopManager::self()->desktopForX11Id(x11Id);
         Q_ASSERT(d);
         if (desktops.contains(d)) {
             continue;
         }
         desktops << d;
     }
     cl->setDesktops(desktops);
 }
 
 void EffectsHandlerImpl::windowToScreen(EffectWindow* w, int screen)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock())
         Workspace::self()->sendClientToScreen(cl, screen);
 }
 
 void EffectsHandlerImpl::setShowingDesktop(bool showing)
 {
     Workspace::self()->setShowingDesktop(showing);
 }
 
 QString EffectsHandlerImpl::currentActivity() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return QString();
     }
     return Activities::self()->current();
 #else
     return QString();
 #endif
 }
 
 int EffectsHandlerImpl::currentDesktop() const
 {
     return VirtualDesktopManager::self()->current();
 }
 
 int EffectsHandlerImpl::numberOfDesktops() const
 {
     return VirtualDesktopManager::self()->count();
 }
 
 void EffectsHandlerImpl::setCurrentDesktop(int desktop)
 {
     VirtualDesktopManager::self()->setCurrent(desktop);
 }
 
 void EffectsHandlerImpl::setNumberOfDesktops(int desktops)
 {
     VirtualDesktopManager::self()->setCount(desktops);
 }
 
 QSize EffectsHandlerImpl::desktopGridSize() const
 {
     return VirtualDesktopManager::self()->grid().size();
 }
 
 int EffectsHandlerImpl::desktopGridWidth() const
 {
     return desktopGridSize().width();
 }
 
 int EffectsHandlerImpl::desktopGridHeight() const
 {
     return desktopGridSize().height();
 }
 
 int EffectsHandlerImpl::workspaceWidth() const
 {
     return desktopGridWidth() * screens()->size().width();
 }
 
 int EffectsHandlerImpl::workspaceHeight() const
 {
     return desktopGridHeight() * screens()->size().height();
 }
 
 int EffectsHandlerImpl::desktopAtCoords(QPoint coords) const
 {
     if (auto vd = VirtualDesktopManager::self()->grid().at(coords)) {
         return vd->x11DesktopNumber();
     }
     return 0;
 }
 
 QPoint EffectsHandlerImpl::desktopGridCoords(int id) const
 {
     return VirtualDesktopManager::self()->grid().gridCoords(id);
 }
 
 QPoint EffectsHandlerImpl::desktopCoords(int id) const
 {
     QPoint coords = VirtualDesktopManager::self()->grid().gridCoords(id);
     if (coords.x() == -1)
         return QPoint(-1, -1);
     const QSize displaySize = screens()->size();
     return QPoint(coords.x() * displaySize.width(), coords.y() * displaySize.height());
 }
 
 int EffectsHandlerImpl::desktopAbove(int desktop, bool wrap) const
 {
     return getDesktop<DesktopAbove>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToRight(int desktop, bool wrap) const
 {
     return getDesktop<DesktopRight>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopBelow(int desktop, bool wrap) const
 {
     return getDesktop<DesktopBelow>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToLeft(int desktop, bool wrap) const
 {
     return getDesktop<DesktopLeft>(desktop, wrap);
 }
 
 QString EffectsHandlerImpl::desktopName(int desktop) const
 {
     return VirtualDesktopManager::self()->name(desktop);
 }
 
 bool EffectsHandlerImpl::optionRollOverDesktops() const
 {
     return options->isRollOverDesktops();
 }
 
 double EffectsHandlerImpl::animationTimeFactor() const
 {
     return options->animationTimeFactor();
 }
 
 WindowQuadType EffectsHandlerImpl::newWindowQuadType()
 {
     return WindowQuadType(next_window_quad_type++);
 }
 
 EffectWindow* EffectsHandlerImpl::findWindow(WId id) const
 {
     if (X11Client *w = Workspace::self()->findClient(Predicate::WindowMatch, id))
         return w->effectWindow();
     if (Unmanaged* w = Workspace::self()->findUnmanaged(id))
         return w->effectWindow();
     if (waylandServer()) {
-        if (XdgShellClient *w = waylandServer()->findClient(id)) {
+        if (AbstractClient *w = waylandServer()->findClient(id)) {
             return w->effectWindow();
         }
     }
     return nullptr;
 }
 
 EffectWindow* EffectsHandlerImpl::findWindow(KWayland::Server::SurfaceInterface *surf) const
 {
     if (waylandServer()) {
-        if (XdgShellClient *w = waylandServer()->findClient(surf)) {
+        if (AbstractClient *w = waylandServer()->findClient(surf)) {
             return w->effectWindow();
         }
     }
     return nullptr;
 }
 
 EffectWindow *EffectsHandlerImpl::findWindow(QWindow *w) const
 {
     if (Toplevel *toplevel = workspace()->findInternal(w)) {
         return toplevel->effectWindow();
     }
     return nullptr;
 }
 
 EffectWindow *EffectsHandlerImpl::findWindow(const QUuid &id) const
 {
     if (const auto client = workspace()->findAbstractClient([&id] (const AbstractClient *c) { return c->internalId() == id; })) {
         return client->effectWindow();
     }
     if (const auto unmanaged = workspace()->findUnmanaged([&id] (const Unmanaged *c) { return c->internalId() == id; })) {
         return unmanaged->effectWindow();
     }
     return nullptr;
 }
 
 EffectWindowList EffectsHandlerImpl::stackingOrder() const
 {
     QList<Toplevel *> list = Workspace::self()->xStackingOrder();
     EffectWindowList ret;
     for (Toplevel *t : list) {
         if (EffectWindow *w = effectWindow(t))
             ret.append(w);
     }
     return ret;
 }
 
 void EffectsHandlerImpl::setElevatedWindow(KWin::EffectWindow* w, bool set)
 {
     elevated_windows.removeAll(w);
     if (set)
         elevated_windows.append(w);
 }
 
 void EffectsHandlerImpl::setTabBoxWindow(EffectWindow* w)
 {
 #ifdef KWIN_BUILD_TABBOX
     if (auto c = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window())) {
         TabBox::TabBox::self()->setCurrentClient(c);
     }
 #else
     Q_UNUSED(w)
 #endif
 }
 
 void EffectsHandlerImpl::setTabBoxDesktop(int desktop)
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->setCurrentDesktop(desktop);
 #else
     Q_UNUSED(desktop)
 #endif
 }
 
 EffectWindowList EffectsHandlerImpl::currentTabBoxWindowList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     const auto clients = TabBox::TabBox::self()->currentClientList();
     EffectWindowList ret;
     ret.reserve(clients.size());
     std::transform(std::cbegin(clients), std::cend(clients),
         std::back_inserter(ret),
         [](auto client) { return client->effectWindow(); });
     return ret;
 #else
     return EffectWindowList();
 #endif
 }
 
 void EffectsHandlerImpl::refTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->reference();
 #endif
 }
 
 void EffectsHandlerImpl::unrefTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->unreference();
 #endif
 }
 
 void EffectsHandlerImpl::closeTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->close();
 #endif
 }
 
 QList< int > EffectsHandlerImpl::currentTabBoxDesktopList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktopList();
 #else
     return QList< int >();
 #endif
 }
 
 int EffectsHandlerImpl::currentTabBoxDesktop() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktop();
 #else
     return -1;
 #endif
 }
 
 EffectWindow* EffectsHandlerImpl::currentTabBoxWindow() const
 {
 #ifdef KWIN_BUILD_TABBOX
     if (auto c = TabBox::TabBox::self()->currentClient())
         return c->effectWindow();
 #endif
     return nullptr;
 }
 
 void EffectsHandlerImpl::addRepaintFull()
 {
     m_compositor->addRepaintFull();
 }
 
 void EffectsHandlerImpl::addRepaint(const QRect& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(const QRegion& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(int x, int y, int w, int h)
 {
     m_compositor->addRepaint(x, y, w, h);
 }
 
 int EffectsHandlerImpl::activeScreen() const
 {
     return screens()->current();
 }
 
 int EffectsHandlerImpl::numScreens() const
 {
     return screens()->count();
 }
 
 int EffectsHandlerImpl::screenNumber(const QPoint& pos) const
 {
     return screens()->number(pos);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, int screen, int desktop) const
 {
     return Workspace::self()->clientArea(opt, screen, desktop);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const EffectWindow* c) const
 {
     const Toplevel* t = static_cast< const EffectWindowImpl* >(c)->window();
     if (const auto *cl = qobject_cast<const AbstractClient *>(t)) {
         return Workspace::self()->clientArea(opt, cl);
     } else {
         return Workspace::self()->clientArea(opt, t->frameGeometry().center(), VirtualDesktopManager::self()->current());
     }
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const QPoint& p, int desktop) const
 {
     return Workspace::self()->clientArea(opt, p, desktop);
 }
 
 QRect EffectsHandlerImpl::virtualScreenGeometry() const
 {
     return screens()->geometry();
 }
 
 QSize EffectsHandlerImpl::virtualScreenSize() const
 {
     return screens()->size();
 }
 
 void EffectsHandlerImpl::defineCursor(Qt::CursorShape shape)
 {
     input()->pointer()->setEffectsOverrideCursor(shape);
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QMouseEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QWheelEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 void EffectsHandlerImpl::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         if (!m_trackingCursorChanges) {
             connect(Cursor::self(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
             Cursor::self()->startCursorTracking();
         }
         ++m_trackingCursorChanges;
     }
     EffectsHandler::connectNotify(signal);
 }
 
 void EffectsHandlerImpl::disconnectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         Q_ASSERT(m_trackingCursorChanges > 0);
         if (!--m_trackingCursorChanges) {
             Cursor::self()->stopCursorTracking();
             disconnect(Cursor::self(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
         }
     }
     EffectsHandler::disconnectNotify(signal);
 }
 
 
 void EffectsHandlerImpl::checkInputWindowStacking()
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return;
     }
     doCheckInputWindowStacking();
 }
 
 void EffectsHandlerImpl::doCheckInputWindowStacking()
 {
 }
 
 QPoint EffectsHandlerImpl::cursorPos() const
 {
     return Cursor::pos();
 }
 
 void EffectsHandlerImpl::reserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->reserve(border, effect, "borderActivated");
 }
 
 void EffectsHandlerImpl::unreserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->unreserve(border, effect);
 }
 
 void EffectsHandlerImpl::registerTouchBorder(ElectricBorder border, QAction *action)
 {
     ScreenEdges::self()->reserveTouch(border, action);
 }
 
 void EffectsHandlerImpl::unregisterTouchBorder(ElectricBorder border, QAction *action)
 {
     ScreenEdges::self()->unreserveTouch(border, action);
 }
 
 unsigned long EffectsHandlerImpl::xrenderBufferPicture()
 {
     return m_scene->xrenderBufferPicture();
 }
 
 QPainter *EffectsHandlerImpl::scenePainter()
 {
     return m_scene->scenePainter();
 }
 
 void EffectsHandlerImpl::toggleEffect(const QString& name)
 {
     if (isEffectLoaded(name))
         unloadEffect(name);
     else
         loadEffect(name);
 }
 
 QStringList EffectsHandlerImpl::loadedEffects() const
 {
     QStringList listModules;
     listModules.reserve(loaded_effects.count());
     std::transform(loaded_effects.constBegin(), loaded_effects.constEnd(),
         std::back_inserter(listModules),
         [](const EffectPair &pair) { return pair.first; });
     return listModules;
 }
 
 QStringList EffectsHandlerImpl::listOfEffects() const
 {
     return m_effectLoader->listOfKnownEffects();
 }
 
 bool EffectsHandlerImpl::loadEffect(const QString& name)
 {
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->loadEffect(name);
 }
 
 void EffectsHandlerImpl::unloadEffect(const QString& name)
 {
     auto it = std::find_if(effect_order.begin(), effect_order.end(),
         [name](EffectPair &pair) {
             return pair.first == name;
         }
     );
     if (it == effect_order.end()) {
         qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Effect not loaded :" << name;
         return;
     }
 
     qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Unloading Effect :" << name;
     destroyEffect((*it).second);
     effect_order.erase(it);
     effectsChanged();
 
     m_compositor->addRepaintFull();
 }
 
 void EffectsHandlerImpl::destroyEffect(Effect *effect)
 {
     makeOpenGLContextCurrent();
 
     if (fullscreen_effect == effect) {
         setActiveFullScreenEffect(nullptr);
     }
 
     if (keyboard_grab_effect == effect) {
         ungrabKeyboard();
     }
 
     stopMouseInterception(effect);
 
     const QList<QByteArray> properties = m_propertiesForEffects.keys();
     for (const QByteArray &property : properties) {
         removeSupportProperty(property, effect);
     }
 
     delete effect;
 }
 
 void EffectsHandlerImpl::reconfigureEffect(const QString& name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name) {
             kwinApp()->config()->reparseConfiguration();
             makeOpenGLContextCurrent();
             (*it).second->reconfigure(Effect::ReconfigureAll);
             return;
         }
 }
 
 bool EffectsHandlerImpl::isEffectLoaded(const QString& name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [&name](const EffectPair &pair) { return pair.first == name; });
     return it != loaded_effects.constEnd();
 }
 
 bool EffectsHandlerImpl::isEffectSupported(const QString &name)
 {
     // If the effect is loaded, it is obviously supported.
     if (isEffectLoaded(name)) {
         return true;
     }
 
     // next checks might require a context
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->isEffectSupported(name);
 
 }
 
 QList<bool> EffectsHandlerImpl::areEffectsSupported(const QStringList &names)
 {
     QList<bool> retList;
     retList.reserve(names.count());
     std::transform(names.constBegin(), names.constEnd(),
         std::back_inserter(retList),
         [this](const QString &name) {
             return isEffectSupported(name);
         });
     return retList;
 }
 
 void EffectsHandlerImpl::reloadEffect(Effect *effect)
 {
     QString effectName;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).second == effect) {
             effectName = (*it).first;
             break;
         }
     }
     if (!effectName.isNull()) {
         unloadEffect(effectName);
         m_effectLoader->loadEffect(effectName);
     }
 }
 
 void EffectsHandlerImpl::effectsChanged()
 {
     loaded_effects.clear();
     m_activeEffects.clear(); // it's possible to have a reconfigure and a quad rebuild between two paint cycles - bug #308201
 
     loaded_effects.reserve(effect_order.count());
     std::copy(effect_order.constBegin(), effect_order.constEnd(),
         std::back_inserter(loaded_effects));
 
     m_activeEffects.reserve(loaded_effects.count());
 }
 
 QStringList EffectsHandlerImpl::activeEffects() const
 {
     QStringList ret;
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(),
                                                     end = loaded_effects.constEnd(); it != end; ++it) {
             if (it->second->isActive()) {
                 ret << it->first;
             }
         }
     return ret;
 }
 
 KWayland::Server::Display *EffectsHandlerImpl::waylandDisplay() const
 {
     if (waylandServer()) {
         return waylandServer()->display();
     }
     return nullptr;
 }
 
 EffectFrame* EffectsHandlerImpl::effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const
 {
     return new EffectFrameImpl(style, staticSize, position, alignment);
 }
 
 
 QVariant EffectsHandlerImpl::kwinOption(KWinOption kwopt)
 {
     switch (kwopt) {
     case CloseButtonCorner:
         // TODO: this could become per window and be derived from the actual position in the deco
         return Decoration::DecorationBridge::self()->settings()->decorationButtonsLeft().contains(KDecoration2::DecorationButtonType::Close) ? Qt::TopLeftCorner : Qt::TopRightCorner;
     case SwitchDesktopOnScreenEdge:
         return ScreenEdges::self()->isDesktopSwitching();
     case SwitchDesktopOnScreenEdgeMovingWindows:
         return ScreenEdges::self()->isDesktopSwitchingMovingClients();
     default:
         return QVariant(); // an invalid one
     }
 }
 
 QString EffectsHandlerImpl::supportInformation(const QString &name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [name](const EffectPair &pair) { return pair.first == name; });
     if (it == loaded_effects.constEnd()) {
         return QString();
     }
 
     QString support((*it).first + QLatin1String(":\n"));
     const QMetaObject *metaOptions = (*it).second->metaObject();
     for (int i=0; i<metaOptions->propertyCount(); ++i) {
         const QMetaProperty property = metaOptions->property(i);
         if (qstrcmp(property.name(), "objectName") == 0) {
             continue;
         }
         support += QString::fromUtf8(property.name()) + QLatin1String(": ") + (*it).second->property(property.name()).toString() + QLatin1Char('\n');
     }
 
     return support;
 }
 
 
 bool EffectsHandlerImpl::isScreenLocked() const
 {
     return ScreenLockerWatcher::self()->isLocked();
 }
 
 QString EffectsHandlerImpl::debug(const QString& name, const QString& parameter) const
 {
     QString internalName = name.toLower();;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == internalName) {
             return it->second->debug(parameter);
         }
     }
     return QString();
 }
 
 bool EffectsHandlerImpl::makeOpenGLContextCurrent()
 {
     return m_scene->makeOpenGLContextCurrent();
 }
 
 void EffectsHandlerImpl::doneOpenGLContextCurrent()
 {
     m_scene->doneOpenGLContextCurrent();
 }
 
 bool EffectsHandlerImpl::animationsSupported() const
 {
     static const QByteArray forceEnvVar = qgetenv("KWIN_EFFECTS_FORCE_ANIMATIONS");
     if (!forceEnvVar.isEmpty()) {
         static const int forceValue = forceEnvVar.toInt();
         return forceValue == 1;
     }
     return m_scene->animationsSupported();
 }
 
 void EffectsHandlerImpl::highlightWindows(const QVector<EffectWindow *> &windows)
 {
     Effect *e = provides(Effect::HighlightWindows);
     if (!e) {
         return;
     }
     e->perform(Effect::HighlightWindows, QVariantList{QVariant::fromValue(windows)});
 }
 
 PlatformCursorImage EffectsHandlerImpl::cursorImage() const
 {
     return kwinApp()->platform()->cursorImage();
 }
 
 void EffectsHandlerImpl::hideCursor()
 {
     kwinApp()->platform()->hideCursor();
 }
 
 void EffectsHandlerImpl::showCursor()
 {
     kwinApp()->platform()->showCursor();
 }
 
 void EffectsHandlerImpl::startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback)
 {
     kwinApp()->platform()->startInteractiveWindowSelection(
         [callback] (KWin::Toplevel *t) {
             if (t && t->effectWindow()) {
                 callback(t->effectWindow());
             } else {
                 callback(nullptr);
             }
         }
     );
 }
 
 void EffectsHandlerImpl::startInteractivePositionSelection(std::function<void(const QPoint&)> callback)
 {
     kwinApp()->platform()->startInteractivePositionSelection(callback);
 }
 
 void EffectsHandlerImpl::showOnScreenMessage(const QString &message, const QString &iconName)
 {
     OSD::show(message, iconName);
 }
 
 void EffectsHandlerImpl::hideOnScreenMessage(OnScreenMessageHideFlags flags)
 {
     OSD::HideFlags osdFlags;
     if (flags.testFlag(OnScreenMessageHideFlag::SkipsCloseAnimation)) {
         osdFlags |= OSD::HideFlag::SkipCloseAnimation;
     }
     OSD::hide(osdFlags);
 }
 
 KSharedConfigPtr EffectsHandlerImpl::config() const
 {
     return kwinApp()->config();
 }
 
 KSharedConfigPtr EffectsHandlerImpl::inputConfig() const
 {
     return kwinApp()->inputConfig();
 }
 
 Effect *EffectsHandlerImpl::findEffect(const QString &name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [name] (const EffectPair &pair) {
             return pair.first == name;
         }
     );
     if (it == loaded_effects.constEnd()) {
         return nullptr;
     }
     return (*it).second;
 }
 
 void EffectsHandlerImpl::renderEffectQuickView(EffectQuickView *w) const
 {
     if (!w->isVisible()) {
         return;
     }
     scene()->paintEffectQuickView(w);
 }
 
 SessionState EffectsHandlerImpl::sessionState() const
 {
     return Workspace::self()->sessionManager()->state();
 }
 
 //****************************************
 // EffectWindowImpl
 //****************************************
 
 EffectWindowImpl::EffectWindowImpl(Toplevel *toplevel)
     : EffectWindow(toplevel)
     , toplevel(toplevel)
     , sw(nullptr)
 {
     // Deleted windows are not managed. So, when windowClosed signal is
     // emitted, effects can't distinguish managed windows from unmanaged
     // windows(e.g. combo box popups, popup menus, etc). Save value of the
     // managed property during construction of EffectWindow. At that time,
     // parent can be Client, XdgShellClient, or Unmanaged. So, later on, when
     // an instance of Deleted becomes parent of the EffectWindow, effects
     // can still figure out whether it is/was a managed window.
     managed = toplevel->isClient();
 
     waylandClient = qobject_cast<KWin::XdgShellClient *>(toplevel) != nullptr;
     x11Client = qobject_cast<KWin::X11Client *>(toplevel) != nullptr ||
         qobject_cast<KWin::Unmanaged *>(toplevel) != nullptr;
 }
 
 EffectWindowImpl::~EffectWindowImpl()
 {
     QVariant cachedTextureVariant = data(LanczosCacheRole);
     if (cachedTextureVariant.isValid()) {
         GLTexture *cachedTexture = static_cast< GLTexture*>(cachedTextureVariant.value<void*>());
         delete cachedTexture;
     }
 }
 
 bool EffectWindowImpl::isPaintingEnabled()
 {
     return sceneWindow()->isPaintingEnabled();
 }
 
 void EffectWindowImpl::enablePainting(int reason)
 {
     sceneWindow()->enablePainting(reason);
 }
 
 void EffectWindowImpl::disablePainting(int reason)
 {
     sceneWindow()->disablePainting(reason);
 }
 
 void EffectWindowImpl::addRepaint(const QRect &r)
 {
     toplevel->addRepaint(r);
 }
 
 void EffectWindowImpl::addRepaint(int x, int y, int w, int h)
 {
     toplevel->addRepaint(x, y, w, h);
 }
 
 void EffectWindowImpl::addRepaintFull()
 {
     toplevel->addRepaintFull();
 }
 
 void EffectWindowImpl::addLayerRepaint(const QRect &r)
 {
     toplevel->addLayerRepaint(r);
 }
 
 void EffectWindowImpl::addLayerRepaint(int x, int y, int w, int h)
 {
     toplevel->addLayerRepaint(x, y, w, h);
 }
 
 const EffectWindowGroup* EffectWindowImpl::group() const
 {
     if (auto c = qobject_cast<X11Client *>(toplevel)) {
         return c->group()->effectGroup();
     }
     return nullptr; // TODO
 }
 
 void EffectWindowImpl::refWindow()
 {
     if (auto d = qobject_cast<Deleted *>(toplevel)) {
         return d->refWindow();
     }
     abort(); // TODO
 }
 
 void EffectWindowImpl::unrefWindow()
 {
     if (auto d = qobject_cast<Deleted *>(toplevel)) {
         return d->unrefWindow();   // delays deletion in case
     }
     abort(); // TODO
 }
 
 #define TOPLEVEL_HELPER( rettype, prototype, toplevelPrototype) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         return toplevel->toplevelPrototype(); \
     }
 
 TOPLEVEL_HELPER(double, opacity, opacity)
 TOPLEVEL_HELPER(bool, hasAlpha, hasAlpha)
 TOPLEVEL_HELPER(int, x, x)
 TOPLEVEL_HELPER(int, y, y)
 TOPLEVEL_HELPER(int, width, width)
 TOPLEVEL_HELPER(int, height, height)
 TOPLEVEL_HELPER(QPoint, pos, pos)
 TOPLEVEL_HELPER(QSize, size, size)
 TOPLEVEL_HELPER(int, screen, screen)
 TOPLEVEL_HELPER(QRect, geometry, frameGeometry)
 TOPLEVEL_HELPER(QRect, frameGeometry, frameGeometry)
 TOPLEVEL_HELPER(QRect, bufferGeometry, bufferGeometry)
 TOPLEVEL_HELPER(QRect, expandedGeometry, visibleRect)
 TOPLEVEL_HELPER(QRect, rect, rect)
 TOPLEVEL_HELPER(int, desktop, desktop)
 TOPLEVEL_HELPER(bool, isDesktop, isDesktop)
 TOPLEVEL_HELPER(bool, isDock, isDock)
 TOPLEVEL_HELPER(bool, isToolbar, isToolbar)
 TOPLEVEL_HELPER(bool, isMenu, isMenu)
 TOPLEVEL_HELPER(bool, isNormalWindow, isNormalWindow)
 TOPLEVEL_HELPER(bool, isDialog, isDialog)
 TOPLEVEL_HELPER(bool, isSplash, isSplash)
 TOPLEVEL_HELPER(bool, isUtility, isUtility)
 TOPLEVEL_HELPER(bool, isDropdownMenu, isDropdownMenu)
 TOPLEVEL_HELPER(bool, isPopupMenu, isPopupMenu)
 TOPLEVEL_HELPER(bool, isTooltip, isTooltip)
 TOPLEVEL_HELPER(bool, isNotification, isNotification)
 TOPLEVEL_HELPER(bool, isCriticalNotification, isCriticalNotification)
 TOPLEVEL_HELPER(bool, isOnScreenDisplay, isOnScreenDisplay)
 TOPLEVEL_HELPER(bool, isComboBox, isComboBox)
 TOPLEVEL_HELPER(bool, isDNDIcon, isDNDIcon)
 TOPLEVEL_HELPER(bool, isDeleted, isDeleted)
 TOPLEVEL_HELPER(bool, hasOwnShape, shape)
 TOPLEVEL_HELPER(QString, windowRole, windowRole)
 TOPLEVEL_HELPER(QStringList, activities, activities)
 TOPLEVEL_HELPER(bool, skipsCloseAnimation, skipsCloseAnimation)
 TOPLEVEL_HELPER(KWayland::Server::SurfaceInterface *, surface, surface)
 TOPLEVEL_HELPER(bool, isPopupWindow, isPopupWindow)
 TOPLEVEL_HELPER(bool, isOutline, isOutline)
 TOPLEVEL_HELPER(pid_t, pid, pid)
 
 #undef TOPLEVEL_HELPER
 
 #define CLIENT_HELPER_WITH_DELETED( rettype, prototype, propertyname, defaultValue ) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         auto client = qobject_cast<AbstractClient *>(toplevel); \
         if (client) { \
             return client->propertyname(); \
         } \
         auto deleted = qobject_cast<Deleted *>(toplevel); \
         if (deleted) { \
             return deleted->propertyname(); \
         } \
         return defaultValue; \
     }
 
 CLIENT_HELPER_WITH_DELETED(bool, isMinimized, isMinimized, false)
 CLIENT_HELPER_WITH_DELETED(bool, isModal, isModal, false)
 CLIENT_HELPER_WITH_DELETED(bool, isFullScreen, isFullScreen, false)
 CLIENT_HELPER_WITH_DELETED(bool, keepAbove, keepAbove, false)
 CLIENT_HELPER_WITH_DELETED(bool, keepBelow, keepBelow, false)
 CLIENT_HELPER_WITH_DELETED(QString, caption, caption, QString());
 CLIENT_HELPER_WITH_DELETED(QVector<uint>, desktops, x11DesktopIds, QVector<uint>());
 
 #undef CLIENT_HELPER_WITH_DELETED
 
 // legacy from tab groups, can be removed when no effects use this any more.
 bool EffectWindowImpl::isCurrentTab() const
 {
     return true;
 }
 
 QString EffectWindowImpl::windowClass() const
 {
     return toplevel->resourceName() + QLatin1Char(' ') + toplevel->resourceClass();
 }
 
 QRect EffectWindowImpl::contentsRect() const
 {
     return QRect(toplevel->clientPos(), toplevel->clientSize());
 }
 
 NET::WindowType EffectWindowImpl::windowType() const
 {
     return toplevel->windowType();
 }
 
 #define CLIENT_HELPER( rettype, prototype, propertyname, defaultValue ) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         auto client = qobject_cast<AbstractClient *>(toplevel); \
         if (client) { \
             return client->propertyname(); \
         } \
         return defaultValue; \
     }
 
 CLIENT_HELPER(bool, isMovable, isMovable, false)
 CLIENT_HELPER(bool, isMovableAcrossScreens, isMovableAcrossScreens, false)
 CLIENT_HELPER(bool, isUserMove, isMove, false)
 CLIENT_HELPER(bool, isUserResize, isResize, false)
 CLIENT_HELPER(QRect, iconGeometry, iconGeometry, QRect())
 CLIENT_HELPER(bool, isSpecialWindow, isSpecialWindow, true)
 CLIENT_HELPER(bool, acceptsFocus, wantsInput, true) // We don't actually know...
 CLIENT_HELPER(QIcon, icon, icon, QIcon())
 CLIENT_HELPER(bool, isSkipSwitcher, skipSwitcher, false)
 CLIENT_HELPER(bool, decorationHasAlpha, decorationHasAlpha, false)
 CLIENT_HELPER(bool, isUnresponsive, unresponsive, false)
 
 #undef CLIENT_HELPER
 
 QSize EffectWindowImpl::basicUnit() const
 {
     if (auto client = qobject_cast<X11Client *>(toplevel)){
         return client->basicUnit();
     }
     return QSize(1,1);
 }
 
 void EffectWindowImpl::setWindow(Toplevel* w)
 {
     toplevel = w;
     setParent(w);
 }
 
 void EffectWindowImpl::setSceneWindow(Scene::Window* w)
 {
     sw = w;
 }
 
 QRegion EffectWindowImpl::shape() const
 {
     if (isX11Client() && sceneWindow()) {
         return sceneWindow()->bufferShape();
     }
     return toplevel->rect();
 }
 
 QRect EffectWindowImpl::decorationInnerRect() const
 {
     auto client = qobject_cast<X11Client *>(toplevel);
     return client ? client->transparentRect() : contentsRect();
 }
 
 QByteArray EffectWindowImpl::readProperty(long atom, long type, int format) const
 {
     if (!kwinApp()->x11Connection()) {
         return QByteArray();
     }
     return readWindowProperty(window()->window(), atom, type, format);
 }
 
 void EffectWindowImpl::deleteProperty(long int atom) const
 {
     if (kwinApp()->x11Connection()) {
         deleteWindowProperty(window()->window(), atom);
     }
 }
 
 EffectWindow* EffectWindowImpl::findModal()
 {
     auto client = qobject_cast<AbstractClient *>(toplevel);
     if (!client) {
         return nullptr;
     }
 
     AbstractClient *modal = client->findModal();
     if (modal) {
         return modal->effectWindow();
     }
 
     return nullptr;
 }
 
 QWindow *EffectWindowImpl::internalWindow() const
 {
     auto client = qobject_cast<InternalClient *>(toplevel);
     if (!client) {
         return nullptr;
     }
     return client->internalWindow();
 }
 
 template <typename T>
 EffectWindowList getMainWindows(T *c)
 {
     const auto mainclients = c->mainClients();
     EffectWindowList ret;
     ret.reserve(mainclients.size());
     std::transform(std::cbegin(mainclients), std::cend(mainclients),
         std::back_inserter(ret),
         [](auto client) { return client->effectWindow(); });
     return ret;
 }
 
 EffectWindowList EffectWindowImpl::mainWindows() const
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         return getMainWindows(client);
     }
     if (auto deleted = qobject_cast<Deleted *>(toplevel)) {
         return getMainWindows(deleted);
     }
     return {};
 }
 
 WindowQuadList EffectWindowImpl::buildQuads(bool force) const
 {
     return sceneWindow()->buildQuads(force);
 }
 
 void EffectWindowImpl::setData(int role, const QVariant &data)
 {
     if (!data.isNull())
         dataMap[ role ] = data;
     else
         dataMap.remove(role);
     emit effects->windowDataChanged(this, role);
 }
 
 QVariant EffectWindowImpl::data(int role) const
 {
     return dataMap.value(role);
 }
 
 EffectWindow* effectWindow(Toplevel* w)
 {
     EffectWindowImpl* ret = w->effectWindow();
     return ret;
 }
 
 EffectWindow* effectWindow(Scene::Window* w)
 {
     EffectWindowImpl* ret = w->window()->effectWindow();
     ret->setSceneWindow(w);
     return ret;
 }
 
 void EffectWindowImpl::elevate(bool elevate)
 {
     effects->setElevatedWindow(this, elevate);
 }
 
 void EffectWindowImpl::registerThumbnail(AbstractThumbnailItem *item)
 {
     if (WindowThumbnailItem *thumb = qobject_cast<WindowThumbnailItem*>(item)) {
         insertThumbnail(thumb);
         connect(thumb, SIGNAL(destroyed(QObject*)), SLOT(thumbnailDestroyed(QObject*)));
         connect(thumb, &WindowThumbnailItem::wIdChanged, this, &EffectWindowImpl::thumbnailTargetChanged);
     } else if (DesktopThumbnailItem *desktopThumb = qobject_cast<DesktopThumbnailItem*>(item)) {
         m_desktopThumbnails.append(desktopThumb);
         connect(desktopThumb, SIGNAL(destroyed(QObject*)), SLOT(desktopThumbnailDestroyed(QObject*)));
     }
 }
 
 void EffectWindowImpl::thumbnailDestroyed(QObject *object)
 {
     // we know it is a ThumbnailItem
     m_thumbnails.remove(static_cast<WindowThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::thumbnailTargetChanged()
 {
     if (WindowThumbnailItem *item = qobject_cast<WindowThumbnailItem*>(sender())) {
         insertThumbnail(item);
     }
 }
 
 void EffectWindowImpl::insertThumbnail(WindowThumbnailItem *item)
 {
     EffectWindow *w = effects->findWindow(item->wId());
     if (w) {
         m_thumbnails.insert(item, QPointer<EffectWindowImpl>(static_cast<EffectWindowImpl*>(w)));
     } else {
         m_thumbnails.insert(item, QPointer<EffectWindowImpl>());
     }
 }
 
 void EffectWindowImpl::desktopThumbnailDestroyed(QObject *object)
 {
     // we know it is a DesktopThumbnailItem
     m_desktopThumbnails.removeAll(static_cast<DesktopThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::minimize()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->minimize();
     }
 }
 
 void EffectWindowImpl::unminimize()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->unminimize();
     }
 }
 
 void EffectWindowImpl::closeWindow()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->closeWindow();
     }
 }
 
 void EffectWindowImpl::referencePreviousWindowPixmap()
 {
     if (sw) {
         sw->referencePreviousPixmap();
     }
 }
 
 void EffectWindowImpl::unreferencePreviousWindowPixmap()
 {
     if (sw) {
         sw->unreferencePreviousPixmap();
     }
 }
 
 bool EffectWindowImpl::isManaged() const
 {
     return managed;
 }
 
 bool EffectWindowImpl::isWaylandClient() const
 {
     return waylandClient;
 }
 
 bool EffectWindowImpl::isX11Client() const
 {
     return x11Client;
 }
 
 
 //****************************************
 // EffectWindowGroupImpl
 //****************************************
 
 
 EffectWindowList EffectWindowGroupImpl::members() const
 {
     const auto memberList = group->members();
     EffectWindowList ret;
     ret.reserve(memberList.size());
     std::transform(std::cbegin(memberList), std::cend(memberList),
         std::back_inserter(ret),
         [](auto toplevel) { return toplevel->effectWindow(); });
     return ret;
 }
 
 //****************************************
 // EffectFrameImpl
 //****************************************
 
 EffectFrameImpl::EffectFrameImpl(EffectFrameStyle style, bool staticSize, QPoint position, Qt::Alignment alignment)
     : QObject(nullptr)
     , EffectFrame()
     , m_style(style)
     , m_static(staticSize)
     , m_point(position)
     , m_alignment(alignment)
     , m_shader(nullptr)
     , m_theme(new Plasma::Theme(this))
 {
     if (m_style == EffectFrameStyled) {
         m_frame.setImagePath(QStringLiteral("widgets/background"));
         m_frame.setCacheAllRenderedFrames(true);
         connect(m_theme, SIGNAL(themeChanged()), this, SLOT(plasmaThemeChanged()));
     }
     m_selection.setImagePath(QStringLiteral("widgets/viewitem"));
     m_selection.setElementPrefix(QStringLiteral("hover"));
     m_selection.setCacheAllRenderedFrames(true);
     m_selection.setEnabledBorders(Plasma::FrameSvg::AllBorders);
 
     m_sceneFrame = Compositor::self()->scene()->createEffectFrame(this);
 }
 
 EffectFrameImpl::~EffectFrameImpl()
 {
     delete m_sceneFrame;
 }
 
 const QFont& EffectFrameImpl::font() const
 {
     return m_font;
 }
 
 void EffectFrameImpl::setFont(const QFont& font)
 {
     if (m_font == font) {
         return;
     }
     m_font = font;
     QRect oldGeom = m_geometry;
     if (!m_text.isEmpty()) {
         autoResize();
     }
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::free()
 {
     m_sceneFrame->free();
 }
 
 const QRect& EffectFrameImpl::geometry() const
 {
     return m_geometry;
 }
 
 void EffectFrameImpl::setGeometry(const QRect& geometry, bool force)
 {
     QRect oldGeom = m_geometry;
     m_geometry = geometry;
     if (m_geometry == oldGeom && !force) {
         return;
     }
     effects->addRepaint(oldGeom);
     effects->addRepaint(m_geometry);
     if (m_geometry.size() == oldGeom.size() && !force) {
         return;
     }
 
     if (m_style == EffectFrameStyled) {
         qreal left, top, right, bottom;
         m_frame.getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         m_frame.resizeFrame(m_geometry.adjusted(-left, -top, right, bottom).size());
     }
 
     free();
 }
 
 const QIcon& EffectFrameImpl::icon() const
 {
     return m_icon;
 }
 
 void EffectFrameImpl::setIcon(const QIcon& icon)
 {
     m_icon = icon;
     if (isCrossFade()) {
         m_sceneFrame->crossFadeIcon();
     }
     if (m_iconSize.isEmpty() && !m_icon.availableSizes().isEmpty()) { // Set a size if we don't already have one
         setIconSize(m_icon.availableSizes().first());
     }
     m_sceneFrame->freeIconFrame();
 }
 
 const QSize& EffectFrameImpl::iconSize() const
 {
     return m_iconSize;
 }
 
 void EffectFrameImpl::setIconSize(const QSize& size)
 {
     if (m_iconSize == size) {
         return;
     }
     m_iconSize = size;
     autoResize();
     m_sceneFrame->freeIconFrame();
 }
 
 void EffectFrameImpl::plasmaThemeChanged()
 {
     free();
 }
 
 void EffectFrameImpl::render(const QRegion &region, double opacity, double frameOpacity)
 {
     if (m_geometry.isEmpty()) {
         return; // Nothing to display
     }
     m_shader = nullptr;
     setScreenProjectionMatrix(static_cast<EffectsHandlerImpl*>(effects)->scene()->screenProjectionMatrix());
     effects->paintEffectFrame(this, region, opacity, frameOpacity);
 }
 
 void EffectFrameImpl::finalRender(QRegion region, double opacity, double frameOpacity) const
 {
     region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
 
     m_sceneFrame->render(region, opacity, frameOpacity);
 }
 
 Qt::Alignment EffectFrameImpl::alignment() const
 {
     return m_alignment;
 }
 
 
 void
 EffectFrameImpl::align(QRect &geometry)
 {
     if (m_alignment & Qt::AlignLeft)
         geometry.moveLeft(m_point.x());
     else if (m_alignment & Qt::AlignRight)
         geometry.moveLeft(m_point.x() - geometry.width());
     else
         geometry.moveLeft(m_point.x() - geometry.width() / 2);
     if (m_alignment & Qt::AlignTop)
         geometry.moveTop(m_point.y());
     else if (m_alignment & Qt::AlignBottom)
         geometry.moveTop(m_point.y() - geometry.height());
     else
         geometry.moveTop(m_point.y() - geometry.height() / 2);
 }
 
 
 void EffectFrameImpl::setAlignment(Qt::Alignment alignment)
 {
     m_alignment = alignment;
     align(m_geometry);
     setGeometry(m_geometry);
 }
 
 void EffectFrameImpl::setPosition(const QPoint& point)
 {
     m_point = point;
     QRect geometry = m_geometry; // this is important, setGeometry need call repaint for old & new geometry
     align(geometry);
     setGeometry(geometry);
 }
 
 const QString& EffectFrameImpl::text() const
 {
     return m_text;
 }
 
 void EffectFrameImpl::setText(const QString& text)
 {
     if (m_text == text) {
         return;
     }
     if (isCrossFade()) {
         m_sceneFrame->crossFadeText();
     }
     m_text = text;
     QRect oldGeom = m_geometry;
     autoResize();
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::setSelection(const QRect& selection)
 {
     if (selection == m_selectionGeometry) {
         return;
     }
     m_selectionGeometry = selection;
     if (m_selectionGeometry.size() != m_selection.frameSize().toSize()) {
         m_selection.resizeFrame(m_selectionGeometry.size());
     }
     // TODO; optimize to only recreate when resizing
     m_sceneFrame->freeSelection();
 }
 
 void EffectFrameImpl::autoResize()
 {
     if (m_static)
         return; // Not automatically resizing
 
     QRect geometry;
     // Set size
     if (!m_text.isEmpty()) {
         QFontMetrics metrics(m_font);
         geometry.setSize(metrics.size(0, m_text));
     }
     if (!m_icon.isNull() && !m_iconSize.isEmpty()) {
         geometry.setLeft(-m_iconSize.width());
         if (m_iconSize.height() > geometry.height())
             geometry.setHeight(m_iconSize.height());
     }
 
     align(geometry);
     setGeometry(geometry);
 }
 
 QColor EffectFrameImpl::styledTextColor()
 {
     return m_theme->color(Plasma::Theme::TextColor);
 }
 
 } // namespace
diff --git a/effects.h b/effects.h
index 589977eb6..71299571d 100644
--- a/effects.h
+++ b/effects.h
@@ -1,679 +1,679 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_EFFECTSIMPL_H
 #define KWIN_EFFECTSIMPL_H
 
 #include "kwineffects.h"
 
 #include "scene.h"
 
 #include <QHash>
 #include <Plasma/FrameSvg>
 
 #include <memory>
 
 namespace Plasma {
 class Theme;
 }
 
 namespace KWayland
 {
 namespace Server
 {
 class Display;
 }
 }
 
 class QDBusPendingCallWatcher;
 class QDBusServiceWatcher;
 
 
 namespace KWin
 {
 
 class AbstractThumbnailItem;
 class DesktopThumbnailItem;
 class WindowThumbnailItem;
 
 class AbstractClient;
 class Compositor;
 class Deleted;
 class EffectLoader;
 class Group;
 class Toplevel;
 class Unmanaged;
 class WindowPropertyNotifyX11Filter;
 class X11Client;
 
 class KWIN_EXPORT EffectsHandlerImpl : public EffectsHandler
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
     Q_PROPERTY(QStringList activeEffects READ activeEffects)
     Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
     Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
 public:
     EffectsHandlerImpl(Compositor *compositor, Scene *scene);
     ~EffectsHandlerImpl() override;
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, const QRegion &region, ScreenPaintData& data) override;
     /**
      * Special hook to perform a paintScreen but just with the windows on @p desktop.
      */
     void paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData& data);
     void postPaintScreen() override;
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
     void postPaintWindow(EffectWindow* w) override;
     void paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity) override;
 
     Effect *provides(Effect::Feature ef);
 
     void drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
 
     void buildQuads(EffectWindow* w, WindowQuadList& quadList) override;
 
     void activateWindow(EffectWindow* c) override;
     EffectWindow* activeWindow() const override;
     void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) override;
     void windowToDesktop(EffectWindow* w, int desktop) override;
     void windowToScreen(EffectWindow* w, int screen) override;
     void setShowingDesktop(bool showing) override;
 
     QString currentActivity() const override;
     int currentDesktop() const override;
     int numberOfDesktops() const override;
     void setCurrentDesktop(int desktop) override;
     void setNumberOfDesktops(int desktops) override;
     QSize desktopGridSize() const override;
     int desktopGridWidth() const override;
     int desktopGridHeight() const override;
     int workspaceWidth() const override;
     int workspaceHeight() const override;
     int desktopAtCoords(QPoint coords) const override;
     QPoint desktopGridCoords(int id) const override;
     QPoint desktopCoords(int id) const override;
     int desktopAbove(int desktop = 0, bool wrap = true) const override;
     int desktopToRight(int desktop = 0, bool wrap = true) const override;
     int desktopBelow(int desktop = 0, bool wrap = true) const override;
     int desktopToLeft(int desktop = 0, bool wrap = true) const override;
     QString desktopName(int desktop) const override;
     bool optionRollOverDesktops() const override;
 
     QPoint cursorPos() const override;
     bool grabKeyboard(Effect* effect) override;
     void ungrabKeyboard() override;
     // not performing XGrabPointer
     void startMouseInterception(Effect *effect, Qt::CursorShape shape) override;
     void stopMouseInterception(Effect *effect) override;
     bool isMouseInterception() const;
     void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) override;
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) override;
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) override;
     void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action) override;
     void* getProxy(QString name) override;
     void startMousePolling() override;
     void stopMousePolling() override;
     EffectWindow* findWindow(WId id) const override;
     EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const override;
     EffectWindow *findWindow(QWindow *w) const override;
     EffectWindow *findWindow(const QUuid &id) const override;
     EffectWindowList stackingOrder() const override;
     void setElevatedWindow(KWin::EffectWindow* w, bool set) override;
 
     void setTabBoxWindow(EffectWindow*) override;
     void setTabBoxDesktop(int) override;
     EffectWindowList currentTabBoxWindowList() const override;
     void refTabBox() override;
     void unrefTabBox() override;
     void closeTabBox() override;
     QList< int > currentTabBoxDesktopList() const override;
     int currentTabBoxDesktop() const override;
     EffectWindow* currentTabBoxWindow() const override;
 
     void setActiveFullScreenEffect(Effect* e) override;
     Effect* activeFullScreenEffect() const override;
     bool hasActiveFullScreenEffect() const override;
 
     void addRepaintFull() override;
     void addRepaint(const QRect& r) override;
     void addRepaint(const QRegion& r) override;
     void addRepaint(int x, int y, int w, int h) override;
     int activeScreen() const override;
     int numScreens() const override;
     int screenNumber(const QPoint& pos) const override;
     QRect clientArea(clientAreaOption, int screen, int desktop) const override;
     QRect clientArea(clientAreaOption, const EffectWindow* c) const override;
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const override;
     QSize virtualScreenSize() const override;
     QRect virtualScreenGeometry() const override;
     double animationTimeFactor() const override;
     WindowQuadType newWindowQuadType() override;
 
     void defineCursor(Qt::CursorShape shape) override;
     bool checkInputWindowEvent(QMouseEvent *e);
     bool checkInputWindowEvent(QWheelEvent *e);
     void checkInputWindowStacking();
 
     void reserveElectricBorder(ElectricBorder border, Effect *effect) override;
     void unreserveElectricBorder(ElectricBorder border, Effect *effect) override;
 
     void registerTouchBorder(ElectricBorder border, QAction *action) override;
     void unregisterTouchBorder(ElectricBorder border, QAction *action) override;
 
     unsigned long xrenderBufferPicture() override;
     QPainter* scenePainter() override;
     void reconfigure() override;
     QByteArray readRootProperty(long atom, long type, int format) const override;
     xcb_atom_t announceSupportProperty(const QByteArray& propertyName, Effect* effect) override;
     void removeSupportProperty(const QByteArray& propertyName, Effect* effect) override;
 
     bool hasDecorationShadows() const override;
 
     bool decorationsHaveAlpha() const override;
 
     bool decorationSupportsBlurBehind() const override;
 
     EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const override;
 
     QVariant kwinOption(KWinOption kwopt) override;
     bool isScreenLocked() const override;
 
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
 
     xcb_connection_t *xcbConnection() const override;
     xcb_window_t x11RootWindow() const override;
 
     // internal (used by kwin core or compositing code)
     void startPaint();
     void grabbedKeyboardEvent(QKeyEvent* e);
     bool hasKeyboardGrab() const;
     void desktopResized(const QSize &size);
 
     void reloadEffect(Effect *effect) override;
     QStringList loadedEffects() const;
     QStringList listOfEffects() const;
     void unloadAllEffects();
 
     QList<EffectWindow*> elevatedWindows() const;
     QStringList activeEffects() const;
 
     /**
      * @returns Whether we are currently in a desktop rendering process triggered by paintDesktop hook
      */
     bool isDesktopRendering() const {
         return m_desktopRendering;
     }
     /**
      * @returns the desktop currently being rendered in the paintDesktop hook.
      */
     int currentRenderedDesktop() const {
         return m_currentRenderedDesktop;
     }
 
     KWayland::Server::Display *waylandDisplay() const override;
 
     bool animationsSupported() const override;
 
     PlatformCursorImage cursorImage() const override;
 
     void hideCursor() override;
     void showCursor() override;
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override;
     void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) override;
 
     void showOnScreenMessage(const QString &message, const QString &iconName = QString()) override;
     void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) override;
 
     KSharedConfigPtr config() const override;
     KSharedConfigPtr inputConfig() const override;
 
     Scene *scene() const {
         return m_scene;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time);
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time);
     bool touchUp(qint32 id, quint32 time);
 
     void highlightWindows(const QVector<EffectWindow *> &windows);
 
     bool isPropertyTypeRegistered(xcb_atom_t atom) const {
         return registered_atoms.contains(atom);
     }
 
     void windowToDesktops(EffectWindow *w, const QVector<uint> &desktops) override;
 
     /**
      * Finds an effect with the given name.
      *
      * @param name The name of the effect.
      * @returns The effect with the given name @p name, or nullptr if there
      *     is no such effect loaded.
      */
     Effect *findEffect(const QString &name) const;
 
     void renderEffectQuickView(EffectQuickView *effectQuickView) const override;
 
     SessionState sessionState() const override;
 
 public Q_SLOTS:
     void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to);
     void slotTabAdded(EffectWindow* from, EffectWindow* to);
     void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow);
 
     // slots for D-Bus interface
     Q_SCRIPTABLE void reconfigureEffect(const QString& name);
     Q_SCRIPTABLE bool loadEffect(const QString& name);
     Q_SCRIPTABLE void toggleEffect(const QString& name);
     Q_SCRIPTABLE void unloadEffect(const QString& name);
     Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const;
     Q_SCRIPTABLE bool isEffectSupported(const QString& name);
     Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
     Q_SCRIPTABLE QString supportInformation(const QString& name) const;
     Q_SCRIPTABLE QString debug(const QString& name, const QString& parameter = QString()) const;
 
 protected Q_SLOTS:
     void slotClientShown(KWin::Toplevel*);
-    void slotXdgShellClientShown(KWin::Toplevel*);
+    void slotWaylandClientShown(KWin::Toplevel*);
     void slotUnmanagedShown(KWin::Toplevel*);
     void slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d);
     void slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode);
     void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity);
     void slotClientModalityChanged();
     void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old);
     void slotFrameGeometryChanged(Toplevel *toplevel, const QRect &oldGeometry);
     void slotPaddingChanged(KWin::Toplevel *t, const QRect &old);
     void slotWindowDamaged(KWin::Toplevel *t, const QRect& r);
 
 protected:
     void connectNotify(const QMetaMethod &signal) override;
     void disconnectNotify(const QMetaMethod &signal) override;
     void effectsChanged();
     void setupAbstractClientConnections(KWin::AbstractClient *c);
     void setupClientConnections(KWin::X11Client *c);
     void setupUnmanagedConnections(KWin::Unmanaged *u);
 
     /**
      * Default implementation does nothing and returns @c true.
      */
     virtual bool doGrabKeyboard();
     /**
      * Default implementation does nothing.
      */
     virtual void doUngrabKeyboard();
 
     /**
      * Default implementation sets Effects override cursor on the PointerInputRedirection.
      */
     virtual void doStartMouseInterception(Qt::CursorShape shape);
 
     /**
      * Default implementation removes the Effects override cursor on the PointerInputRedirection.
      */
     virtual void doStopMouseInterception();
 
     /**
      * Default implementation does nothing
      */
     virtual void doCheckInputWindowStacking();
 
     Effect* keyboard_grab_effect;
     Effect* fullscreen_effect;
     QList<EffectWindow*> elevated_windows;
     QMultiMap< int, EffectPair > effect_order;
     QHash< long, int > registered_atoms;
     int next_window_quad_type;
 
 private:
     void registerPropertyType(long atom, bool reg);
     void destroyEffect(Effect *effect);
 
     typedef QVector< Effect*> EffectsList;
     typedef EffectsList::const_iterator EffectsIterator;
     EffectsList m_activeEffects;
     EffectsIterator m_currentDrawWindowIterator;
     EffectsIterator m_currentPaintWindowIterator;
     EffectsIterator m_currentPaintEffectFrameIterator;
     EffectsIterator m_currentPaintScreenIterator;
     EffectsIterator m_currentBuildQuadsIterator;
     typedef QHash< QByteArray, QList< Effect*> > PropertyEffectMap;
     PropertyEffectMap m_propertiesForEffects;
     QHash<QByteArray, qulonglong> m_managedProperties;
     Compositor *m_compositor;
     Scene *m_scene;
     bool m_desktopRendering;
     int m_currentRenderedDesktop;
     QList<Effect*> m_grabbedMouseEffects;
     EffectLoader *m_effectLoader;
     int m_trackingCursorChanges;
     std::unique_ptr<WindowPropertyNotifyX11Filter> m_x11WindowPropertyNotify;
 };
 
 class EffectWindowImpl : public EffectWindow
 {
     Q_OBJECT
 public:
     explicit EffectWindowImpl(Toplevel *toplevel);
     ~EffectWindowImpl() override;
 
     void enablePainting(int reason) override;
     void disablePainting(int reason) override;
     bool isPaintingEnabled() override;
 
     void addRepaint(const QRect &r) override;
     void addRepaint(int x, int y, int w, int h) override;
     void addRepaintFull() override;
     void addLayerRepaint(const QRect &r) override;
     void addLayerRepaint(int x, int y, int w, int h) override;
 
     void refWindow() override;
     void unrefWindow() override;
 
     const EffectWindowGroup* group() const override;
 
     bool isDeleted() const override;
     bool isMinimized() const override;
     double opacity() const override;
     bool hasAlpha() const override;
 
     QStringList activities() const override;
     int desktop() const override;
     QVector<uint> desktops() const override;
     int x() const override;
     int y() const override;
     int width() const override;
     int height() const override;
 
     QSize basicUnit() const override;
     QRect geometry() const override;
     QRect frameGeometry() const override;
     QRect bufferGeometry() const override;
 
     QString caption() const override;
 
     QRect expandedGeometry() const override;
     QRegion shape() const override;
     int screen() const override;
     bool hasOwnShape() const override; // only for shadow effect, for now
     QPoint pos() const override;
     QSize size() const override;
     QRect rect() const override;
 
     bool isMovable() const override;
     bool isMovableAcrossScreens() const override;
     bool isUserMove() const override;
     bool isUserResize() const override;
     QRect iconGeometry() const override;
 
     bool isDesktop() const override;
     bool isDock() const override;
     bool isToolbar() const override;
     bool isMenu() const override;
     bool isNormalWindow() const override;
     bool isSpecialWindow() const override;
     bool isDialog() const override;
     bool isSplash() const override;
     bool isUtility() const override;
     bool isDropdownMenu() const override;
     bool isPopupMenu() const override;
     bool isTooltip() const override;
     bool isNotification() const override;
     bool isCriticalNotification() const override;
     bool isOnScreenDisplay() const override;
     bool isComboBox() const override;
     bool isDNDIcon() const override;
     bool skipsCloseAnimation() const override;
 
     bool acceptsFocus() const override;
     bool keepAbove() const override;
     bool keepBelow() const override;
     bool isModal() const override;
     bool isPopupWindow() const override;
     bool isOutline() const override;
 
     KWayland::Server::SurfaceInterface *surface() const override;
     bool isFullScreen() const override;
     bool isUnresponsive() const override;
 
     QRect contentsRect() const override;
     bool decorationHasAlpha() const override;
     QIcon icon() const override;
     QString windowClass() const override;
     NET::WindowType windowType() const override;
     bool isSkipSwitcher() const override;
     bool isCurrentTab() const override;
     QString windowRole() const override;
 
     bool isManaged() const override;
     bool isWaylandClient() const override;
     bool isX11Client() const override;
 
     pid_t pid() const override;
 
     QRect decorationInnerRect() const override;
     QByteArray readProperty(long atom, long type, int format) const override;
     void deleteProperty(long atom) const override;
 
     EffectWindow* findModal() override;
     EffectWindowList mainWindows() const override;
 
     WindowQuadList buildQuads(bool force = false) const override;
 
     void minimize() override;
     void unminimize() override;
     void closeWindow() override;
 
     void referencePreviousWindowPixmap() override;
     void unreferencePreviousWindowPixmap() override;
 
     QWindow *internalWindow() const override;
 
     const Toplevel* window() const;
     Toplevel* window();
 
     void setWindow(Toplevel* w);   // internal
     void setSceneWindow(Scene::Window* w);   // internal
     const Scene::Window* sceneWindow() const; // internal
     Scene::Window* sceneWindow(); // internal
 
     void elevate(bool elevate);
 
     void setData(int role, const QVariant &data) override;
     QVariant data(int role) const override;
 
     void registerThumbnail(AbstractThumbnailItem *item);
     QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > const &thumbnails() const {
         return m_thumbnails;
     }
     QList<DesktopThumbnailItem*> const &desktopThumbnails() const {
         return m_desktopThumbnails;
     }
 
 private Q_SLOTS:
     void thumbnailDestroyed(QObject *object);
     void thumbnailTargetChanged();
     void desktopThumbnailDestroyed(QObject *object);
 private:
     void insertThumbnail(WindowThumbnailItem *item);
     Toplevel* toplevel;
     Scene::Window* sw; // This one is used only during paint pass.
     QHash<int, QVariant> dataMap;
     QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > m_thumbnails;
     QList<DesktopThumbnailItem*> m_desktopThumbnails;
     bool managed = false;
     bool waylandClient;
     bool x11Client;
 };
 
 class EffectWindowGroupImpl
     : public EffectWindowGroup
 {
 public:
     explicit EffectWindowGroupImpl(Group* g);
     EffectWindowList members() const override;
 private:
     Group* group;
 };
 
 class KWIN_EXPORT EffectFrameImpl
     : public QObject, public EffectFrame
 {
     Q_OBJECT
 public:
     explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1),
                              Qt::Alignment alignment = Qt::AlignCenter);
     ~EffectFrameImpl() override;
 
     void free() override;
     void render(const QRegion &region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) override;
     Qt::Alignment alignment() const override;
     void setAlignment(Qt::Alignment alignment) override;
     const QFont& font() const override;
     void setFont(const QFont& font) override;
     const QRect& geometry() const override;
     void setGeometry(const QRect& geometry, bool force = false) override;
     const QIcon& icon() const override;
     void setIcon(const QIcon& icon) override;
     const QSize& iconSize() const override;
     void setIconSize(const QSize& size) override;
     void setPosition(const QPoint& point) override;
     const QString& text() const override;
     void setText(const QString& text) override;
     EffectFrameStyle style() const override {
         return m_style;
     };
     Plasma::FrameSvg& frame() {
         return m_frame;
     }
     bool isStatic() const {
         return m_static;
     };
     void finalRender(QRegion region, double opacity, double frameOpacity) const;
     void setShader(GLShader* shader) override {
         m_shader = shader;
     }
     GLShader* shader() const override {
         return m_shader;
     }
     void setSelection(const QRect& selection) override;
     const QRect& selection() const {
         return m_selectionGeometry;
     }
     Plasma::FrameSvg& selectionFrame() {
         return m_selection;
     }
     /**
      * The foreground text color as specified by the default Plasma theme.
      */
     QColor styledTextColor();
 
 private Q_SLOTS:
     void plasmaThemeChanged();
 
 private:
     Q_DISABLE_COPY(EffectFrameImpl)   // As we need to use Qt slots we cannot copy this class
     void align(QRect &geometry);   // positions geometry around m_point respecting m_alignment
     void autoResize(); // Auto-resize if not a static size
 
     EffectFrameStyle m_style;
     Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames
     Plasma::FrameSvg m_selection;
 
     // Position
     bool m_static;
     QPoint m_point;
     Qt::Alignment m_alignment;
     QRect m_geometry;
 
     // Contents
     QString m_text;
     QFont m_font;
     QIcon m_icon;
     QSize m_iconSize;
     QRect m_selectionGeometry;
 
     Scene::EffectFrame* m_sceneFrame;
     GLShader* m_shader;
 
     Plasma::Theme *m_theme;
 };
 
 inline
 QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
 {
     if (isScreenLocked())
         return QList<EffectWindow*>();
     return elevated_windows;
 }
 
 inline
 xcb_window_t EffectsHandlerImpl::x11RootWindow() const
 {
     return rootWindow();
 }
 
 inline
 xcb_connection_t *EffectsHandlerImpl::xcbConnection() const
 {
     return connection();
 }
 
 inline
 EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g)
     : group(g)
 {
 }
 
 EffectWindow* effectWindow(Toplevel* w);
 EffectWindow* effectWindow(Scene::Window* w);
 
 inline
 const Scene::Window* EffectWindowImpl::sceneWindow() const
 {
     return sw;
 }
 
 inline
 Scene::Window* EffectWindowImpl::sceneWindow()
 {
     return sw;
 }
 
 inline
 const Toplevel* EffectWindowImpl::window() const
 {
     return toplevel;
 }
 
 inline
 Toplevel* EffectWindowImpl::window()
 {
     return toplevel;
 }
 
 
 } // namespace
 
 #endif
diff --git a/idle_inhibition.cpp b/idle_inhibition.cpp
index fc662af64..f2d502639 100644
--- a/idle_inhibition.cpp
+++ b/idle_inhibition.cpp
@@ -1,121 +1,121 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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 "idle_inhibition.h"
+#include "abstract_client.h"
 #include "deleted.h"
-#include "xdgshellclient.h"
 #include "workspace.h"
 
 #include <KWayland/Server/idle_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include <algorithm>
 #include <functional>
 
 using KWayland::Server::SurfaceInterface;
 
 namespace KWin
 {
 
 IdleInhibition::IdleInhibition(IdleInterface *idle)
     : QObject(idle)
     , m_idle(idle)
 {
     // Workspace is created after the wayland server is initialized.
     connect(kwinApp(), &Application::workspaceCreated, this, &IdleInhibition::slotWorkspaceCreated);
 }
 
 IdleInhibition::~IdleInhibition() = default;
 
-void IdleInhibition::registerXdgShellClient(XdgShellClient *client)
+void IdleInhibition::registerClient(AbstractClient *client)
 {
     auto updateInhibit = [this, client] {
         update(client);
     };
 
     m_connections[client] = connect(client->surface(), &SurfaceInterface::inhibitsIdleChanged, this, updateInhibit);
-    connect(client, &XdgShellClient::desktopChanged, this, updateInhibit);
-    connect(client, &XdgShellClient::clientMinimized, this, updateInhibit);
-    connect(client, &XdgShellClient::clientUnminimized, this, updateInhibit);
-    connect(client, &XdgShellClient::windowHidden, this, updateInhibit);
-    connect(client, &XdgShellClient::windowShown, this, updateInhibit);
-    connect(client, &XdgShellClient::windowClosed, this,
+    connect(client, &AbstractClient::desktopChanged, this, updateInhibit);
+    connect(client, &AbstractClient::clientMinimized, this, updateInhibit);
+    connect(client, &AbstractClient::clientUnminimized, this, updateInhibit);
+    connect(client, &AbstractClient::windowHidden, this, updateInhibit);
+    connect(client, &AbstractClient::windowShown, this, updateInhibit);
+    connect(client, &AbstractClient::windowClosed, this,
         [this, client] {
             uninhibit(client);
             auto it = m_connections.find(client);
             if (it != m_connections.end()) {
                 disconnect(it.value());
                 m_connections.erase(it);
             }
         }
     );
 
     updateInhibit();
 }
 
 void IdleInhibition::inhibit(AbstractClient *client)
 {
     if (isInhibited(client)) {
         // already inhibited
         return;
     }
     m_idleInhibitors << client;
     m_idle->inhibit();
     // TODO: notify powerdevil?
 }
 
 void IdleInhibition::uninhibit(AbstractClient *client)
 {
     auto it = std::find(m_idleInhibitors.begin(), m_idleInhibitors.end(), client);
     if (it == m_idleInhibitors.end()) {
         // not inhibited
         return;
     }
     m_idleInhibitors.erase(it);
     m_idle->uninhibit();
 }
 
 void IdleInhibition::update(AbstractClient *client)
 {
     if (client->isInternal()) {
         return;
     }
 
     // TODO: Don't honor the idle inhibitor object if the shell client is not
     // on the current activity (currently, activities are not supported).
     const bool visible = client->isShown(true) && client->isOnCurrentDesktop();
     if (visible && client->surface()->inhibitsIdle()) {
         inhibit(client);
     } else {
         uninhibit(client);
     }
 }
 
 void IdleInhibition::slotWorkspaceCreated()
 {
     connect(workspace(), &Workspace::currentDesktopChanged, this, &IdleInhibition::slotDesktopChanged);
 }
 
 void IdleInhibition::slotDesktopChanged()
 {
     workspace()->forEachAbstractClient([this] (AbstractClient *c) { update(c); });
 }
 
 }
diff --git a/idle_inhibition.h b/idle_inhibition.h
index 8a1efc824..aefa487de 100644
--- a/idle_inhibition.h
+++ b/idle_inhibition.h
@@ -1,71 +1,70 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@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/>.
 *********************************************************************/
 #pragma once
 
 #include <QObject>
 #include <QVector>
 #include <QMap>
 
 namespace KWayland
 {
 namespace Server
 {
 class IdleInterface;
 }
 }
 
 using KWayland::Server::IdleInterface;
 
 namespace KWin
 {
 class AbstractClient;
-class XdgShellClient;
 
 class IdleInhibition : public QObject
 {
     Q_OBJECT
 public:
     explicit IdleInhibition(IdleInterface *idle);
     ~IdleInhibition() override;
 
-    void registerXdgShellClient(XdgShellClient *client);
+    void registerClient(AbstractClient *client);
 
     bool isInhibited() const {
         return !m_idleInhibitors.isEmpty();
     }
     bool isInhibited(AbstractClient *client) const {
         return m_idleInhibitors.contains(client);
     }
 
 private Q_SLOTS:
     void slotWorkspaceCreated();
     void slotDesktopChanged();
 
 private:
     void inhibit(AbstractClient *client);
     void uninhibit(AbstractClient *client);
     void update(AbstractClient *client);
 
     IdleInterface *m_idle;
     QVector<AbstractClient *> m_idleInhibitors;
     QMap<AbstractClient *, QMetaObject::Connection> m_connections;
 };
 }
diff --git a/input.cpp b/input.cpp
index b2032cf3e..08cf5164e 100644
--- a/input.cpp
+++ b/input.cpp
@@ -1,2551 +1,2550 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "input.h"
 #include "effects.h"
 #include "gestures.h"
 #include "globalshortcuts.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "keyboard_input.h"
 #include "logind.h"
 #include "main.h"
 #include "pointer_input.h"
 #include "tablet_input.h"
 #include "touch_hide_cursor_spy.h"
 #include "touch_input.h"
 #include "x11client.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox/tabbox.h"
 #endif
 #include "unmanaged.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "workspace.h"
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #include "platform.h"
 #include "popup_input_filter.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "xwl/xwayland_interface.h"
 #include "internal_client.h"
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/fakeinput_interface.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/relativepointer_interface.h>
 #include <decorations/decoratedclient.h>
 #include <KDecoration2/Decoration>
 #include <KGlobalAccel>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 // Qt
 #include <QKeyEvent>
 
 #include <xkbcommon/xkbcommon.h>
 
 namespace KWin
 {
 
 InputEventFilter::InputEventFilter() = default;
 
 InputEventFilter::~InputEventFilter()
 {
     if (input()) {
         input()->uninstallInputEventFilter(this);
     }
 }
 
 bool InputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     return false;
 }
 
 bool InputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::keyEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::touchDown(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchMotion(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchUp(qint32 id, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(scale)
     Q_UNUSED(angleDelta)
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::switchEvent(SwitchEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::tabletToolEvent(QTabletEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::tabletToolButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
     return false;
 }
 
 bool InputEventFilter::tabletPadButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
     return false;
 }
 
 bool InputEventFilter::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
     return false;
 }
 
 bool InputEventFilter::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
     return false;
 }
 
 void InputEventFilter::passToWaylandServer(QKeyEvent *event)
 {
     Q_ASSERT(waylandServer());
     if (event->isAutoRepeat()) {
         return;
     }
     switch (event->type()) {
     case QEvent::KeyPress:
         waylandServer()->seat()->keyPressed(event->nativeScanCode());
         break;
     case QEvent::KeyRelease:
         waylandServer()->seat()->keyReleased(event->nativeScanCode());
         break;
     default:
         break;
     }
 }
 
 class VirtualTerminalFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         // really on press and not on release? X11 switches on press.
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             const xkb_keysym_t keysym = event->nativeVirtualKey();
             if (keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12) {
                 LogindIntegration::self()->switchVirtualTerminal(keysym - XKB_KEY_XF86Switch_VT_1 + 1);
                 return true;
             }
         }
         return false;
     }
 };
 
 class TerminateServerFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             if (event->nativeVirtualKey() == XKB_KEY_Terminate_Server) {
                 qCWarning(KWIN_CORE) << "Request to terminate server";
                 QMetaObject::invokeMethod(qApp, "quit", Qt::QueuedConnection);
                 return true;
             }
         }
         return false;
     }
 };
 
 class LockScreenFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (event->type() == QEvent::MouseMove) {
             if (pointerSurfaceAllowed()) {
                 // TODO: should the pointer position always stay in sync, i.e. not do the check?
                 seat->setPointerPos(event->screenPos().toPoint());
             }
         } else if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonRelease) {
             if (pointerSurfaceAllowed()) {
                 // TODO: can we leak presses/releases here when we move the mouse in between from an allowed surface to
                 //       disallowed one or vice versa?
                 event->type() == QEvent::MouseButtonPress ? seat->pointerButtonPressed(nativeButton) : seat->pointerButtonReleased(nativeButton);
             }
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         if (pointerSurfaceAllowed()) {
             seat->setTimestamp(event->timestamp());
             const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
             seat->pointerAxis(orientation, orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y());
         }
         return true;
     }
     bool keyEvent(QKeyEvent * event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // wayland client takes care of it
             return true;
         }
         // send event to KSldApp for global accel
         // if event is set to accepted it means a whitelisted shortcut was triggered
         // in that case we filter it out and don't process it further
         event->setAccepted(false);
         QCoreApplication::sendEvent(ScreenLocker::KSldApp::self(), event);
         if (event->isAccepted()) {
             return true;
         }
 
         // continue normal processing
         input()->keyboard()->update();
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (!keyboardSurfaceAllowed()) {
             // don't pass event to seat
             return true;
         }
         switch (event->type()) {
         case QEvent::KeyPress:
             seat->keyPressed(event->nativeScanCode());
             break;
         case QEvent::KeyRelease:
             seat->keyReleased(event->nativeScanCode());
             break;
         default:
             break;
         }
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             input()->touch()->insertId(id, seat->touchDown(pos));
         }
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchMove(kwaylandId, pos);
             }
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchUp(kwaylandId);
                 input()->touch()->removeId(id);
             }
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         Q_UNUSED(scale)
         Q_UNUSED(angleDelta)
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 private:
     bool surfaceAllowed(KWayland::Server::SurfaceInterface *(KWayland::Server::SeatInterface::*method)() const) const {
         if (KWayland::Server::SurfaceInterface *s = (waylandServer()->seat()->*method)()) {
             if (Toplevel *t = waylandServer()->findClient(s)) {
                 return t->isLockScreen() || t->isInputMethod();
             }
             return false;
         }
         return true;
     }
     bool pointerSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedPointerSurface);
     }
     bool keyboardSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedKeyboardSurface);
     }
     bool touchSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedTouchSurface);
     }
 };
 
 class EffectsFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!effects) {
             return false;
         }
         return static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event);
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!effects) {
             return false;
         }
         return static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!effects || !static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(event);
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchDown(id, pos, time);
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchMotion(id, pos, time);
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchUp(id, time);
     }
 };
 
 class MoveResizeFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseMove:
             c->updateMoveResize(event->screenPos().toPoint());
             break;
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 c->endMoveResize();
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while moving a window
         return workspace()->moveResizeClient() != nullptr;
     }
     bool keyEvent(QKeyEvent *event) override {
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (event->type() == QEvent::KeyPress) {
             c->keyPressEvent(event->key() | event->modifiers());
             if (c->isMove() || c->isResize()) {
                 // only update if mode didn't end
                 c->updateMoveResize(input()->globalPointer());
             }
         }
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(id)
         Q_UNUSED(pos)
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         return true;
     }
 
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (!m_set) {
             m_id = id;
             m_set = true;
         }
         if (m_id == id) {
             c->updateMoveResize(pos.toPoint());
         }
         return true;
     }
 
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (m_id == id || !m_set) {
             c->endMoveResize();
             m_set = false;
             // pass through to update decoration filter later on
             return false;
         }
         m_set = false;
         return true;
     }
 private:
     qint32 m_id = 0;
     bool m_set = false;
 };
 
 class WindowSelectorFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!m_active) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 if (event->button() == Qt::RightButton) {
                     cancel();
                 } else {
                     accept(event->globalPos());
                 }
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while selecting a window
         return m_active;
     }
     bool keyEvent(QKeyEvent *event) override {
         Q_UNUSED(event)
         if (!m_active) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             // x11 variant does this on key press, so do the same
             if (event->key() == Qt::Key_Escape) {
                 cancel();
             } else if (event->key() == Qt::Key_Enter ||
                        event->key() == Qt::Key_Return ||
                        event->key() == Qt::Key_Space) {
                 accept(input()->globalPointer());
             }
             if (input()->supportsPointerWarping()) {
                 int mx = 0;
                 int my = 0;
                 if (event->key() == Qt::Key_Left) {
                     mx = -10;
                 }
                 if (event->key() == Qt::Key_Right) {
                     mx = 10;
                 }
                 if (event->key() == Qt::Key_Up) {
                     my = -10;
                 }
                 if (event->key() == Qt::Key_Down) {
                     my = 10;
                 }
                 if (event->modifiers() & Qt::ControlModifier) {
                     mx /= 10;
                     my /= 10;
                 }
                 input()->warpPointer(input()->globalPointer() + QPointF(mx, my));
             }
         }
         // filter out while selecting a window
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         m_touchPoints.insert(id, pos);
         return true;
     }
 
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         auto it = m_touchPoints.find(id);
         if (it != m_touchPoints.end()) {
             *it = pos;
         }
         return true;
     }
 
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         auto it = m_touchPoints.find(id);
         if (it != m_touchPoints.end()) {
             const auto pos = it.value();
             m_touchPoints.erase(it);
             if (m_touchPoints.isEmpty()) {
                 accept(pos);
             }
         }
         return true;
     }
 
     bool isActive() const {
         return m_active;
     }
     void start(std::function<void(KWin::Toplevel*)> callback) {
         Q_ASSERT(!m_active);
         m_active = true;
         m_callback = callback;
         input()->keyboard()->update();
         input()->cancelTouch();
     }
     void start(std::function<void(const QPoint &)> callback) {
         Q_ASSERT(!m_active);
         m_active = true;
         m_pointSelectionFallback = callback;
         input()->keyboard()->update();
         input()->cancelTouch();
     }
 private:
     void deactivate() {
         m_active = false;
         m_callback = std::function<void(KWin::Toplevel*)>();
         m_pointSelectionFallback = std::function<void(const QPoint &)>();
         input()->pointer()->removeWindowSelectionCursor();
         input()->keyboard()->update();
         m_touchPoints.clear();
     }
     void cancel() {
         if (m_callback) {
             m_callback(nullptr);
         }
         if (m_pointSelectionFallback) {
             m_pointSelectionFallback(QPoint(-1, -1));
         }
         deactivate();
     }
     void accept(const QPoint &pos) {
         if (m_callback) {
             // TODO: this ignores shaped windows
             m_callback(input()->findToplevel(pos));
         }
         if (m_pointSelectionFallback) {
             m_pointSelectionFallback(pos);
         }
         deactivate();
     }
     void accept(const QPointF &pos) {
         accept(pos.toPoint());
     }
     bool m_active = false;
     std::function<void(KWin::Toplevel*)> m_callback;
     std::function<void(const QPoint &)> m_pointSelectionFallback;
     QMap<quint32, QPointF> m_touchPoints;
 };
 
 class GlobalShortcutFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton);
         if (event->type() == QEvent::MouseButtonPress) {
             if (input()->shortcuts()->processPointerPressed(event->modifiers(), event->buttons())) {
                 return true;
             }
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->modifiers() == Qt::NoModifier) {
             return false;
         }
         PointerAxisDirection direction = PointerAxisUp;
         if (event->angleDelta().x() < 0) {
             direction = PointerAxisRight;
         } else if (event->angleDelta().x() > 0) {
             direction = PointerAxisLeft;
         } else if (event->angleDelta().y() < 0) {
             direction = PointerAxisDown;
         } else if (event->angleDelta().y() > 0) {
             direction = PointerAxisUp;
         }
         return input()->shortcuts()->processAxis(event->modifiers(), direction);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (event->key() == Qt::Key_PowerOff) {
             if (event->type() == QEvent::KeyPress) {
                 m_powerOffPress = event->timestamp();
             } else if (event->type() == QEvent::KeyRelease) {
                 const uint duration = (event->timestamp() - m_powerOffPress);
                 const Qt::Key key = duration > 1000 ? Qt::Key_PowerDown : Qt::Key_PowerOff;
                 const auto shortcuts = static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts();
                 return input()->shortcuts()->processKey(shortcuts, key | (event->key() & ~Qt::KeyboardModifierMask));
             }
         } else if (event->type() == QEvent::KeyPress) {
             return input()->shortcuts()->processKey(static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts(), event->key());
         }
         return false;
     }
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeStart(fingerCount);
         return false;
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeUpdate(delta);
         return false;
     }
     bool swipeGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeCancel();
         return false;
     }
     bool swipeGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeEnd();
         return false;
     }
 
 private:
     uint m_powerOffPress;
 };
 
 
 namespace {
 
 enum class MouseAction {
     ModifierOnly,
     ModifierAndWindow
 };
 std::pair<bool, bool> performClientMouseAction(QMouseEvent *event, AbstractClient *client, MouseAction action = MouseAction::ModifierOnly)
 {
     Options::MouseCommand command = Options::MouseNothing;
     bool wasAction = false;
     if (static_cast<MouseEvent*>(event)->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
         if (!input()->pointer()->isConstrained() && !workspace()->globalShortcutsDisabled()) {
             wasAction = true;
             switch (event->button()) {
             case Qt::LeftButton:
                 command = options->commandAll1();
                 break;
             case Qt::MiddleButton:
                 command = options->commandAll2();
                 break;
             case Qt::RightButton:
                 command = options->commandAll3();
                 break;
             default:
                 // nothing
                 break;
             }
         }
     } else {
         if (action == MouseAction::ModifierAndWindow) {
             command = client->getMouseCommand(event->button(), &wasAction);
         }
     }
     if (wasAction) {
         return std::make_pair(wasAction, !client->performMouseCommand(command, event->globalPos()));
     }
     return std::make_pair(wasAction, false);
 }
 
 std::pair<bool, bool> performClientWheelAction(QWheelEvent *event, AbstractClient *c, MouseAction action = MouseAction::ModifierOnly)
 {
     bool wasAction = false;
     Options::MouseCommand command = Options::MouseNothing;
     if (static_cast<WheelEvent*>(event)->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
         if (!input()->pointer()->isConstrained() && !workspace()->globalShortcutsDisabled()) {
             wasAction = true;
             command = options->operationWindowMouseWheel(-1 * event->angleDelta().y());
         }
     } else {
         if (action == MouseAction::ModifierAndWindow) {
             command = c->getWheelCommand(Qt::Vertical, &wasAction);
         }
     }
     if (wasAction) {
         return std::make_pair(wasAction, !c->performMouseCommand(command, event->globalPos()));
     }
     return std::make_pair(wasAction, false);
 }
 
 }
 
 class InternalWindowEventFilter : public InputEventFilter {
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         // find client
         switch (event->type())
         {
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease: {
             auto s = qobject_cast<InternalClient *>(workspace()->findInternal(internal));
             if (s && s->isDecorated()) {
                 // only perform mouse commands on decorated internal windows
                 const auto actionResult = performClientMouseAction(event, s);
                 if (actionResult.first) {
                     return actionResult.second;
                 }
             }
             break;
         }
         default:
             break;
         }
         QMouseEvent e(event->type(),
                         event->pos() - internal->position(),
                         event->globalPos(),
                         event->button(), event->buttons(), event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         if (event->angleDelta().y() != 0) {
             auto s = qobject_cast<InternalClient *>(workspace()->findInternal(internal));
             if (s && s->isDecorated()) {
                 // client window action only on vertical scrolling
                 const auto actionResult = performClientWheelAction(event, s);
                 if (actionResult.first) {
                     return actionResult.second;
                 }
             }
         }
         const QPointF localPos = event->globalPosF() - QPointF(internal->x(), internal->y());
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta() * -1,
                         delta * -1,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool keyEvent(QKeyEvent *event) override {
         const QList<InternalClient *> &internalClients = workspace()->internalClients();
         if (internalClients.isEmpty()) {
             return false;
         }
         QWindow *found = nullptr;
         auto it = internalClients.end();
         do {
             it--;
             if (QWindow *w = (*it)->internalWindow()) {
                 if (!w->isVisible()) {
                     continue;
                 }
                 if (!screens()->geometry().contains(w->geometry())) {
                     continue;
                 }
                 if (w->property("_q_showWithoutActivating").toBool()) {
                     continue;
                 }
                 if (w->property("outputOnly").toBool()) {
                     continue;
                 }
                 if (w->flags().testFlag(Qt::ToolTip)) {
                     continue;
                 }
                 found = w;
                 break;
             }
         } while (it != internalClients.begin());
         if (!found) {
             return false;
         }
         auto xkb = input()->keyboard()->xkb();
         Qt::Key key = xkb->toQtKey(xkb->toKeysym(event->nativeScanCode()));
         if (key == Qt::Key_Super_L || key == Qt::Key_Super_R) {
             // workaround for QTBUG-62102
             key = Qt::Key_Meta;
         }
         QKeyEvent internalEvent(event->type(), key,
                                 event->modifiers(), event->nativeScanCode(), event->nativeVirtualKey(),
                                 event->nativeModifiers(), event->text());
         internalEvent.setAccepted(false);
         if (QCoreApplication::sendEvent(found, &internalEvent)) {
             waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
             passToWaylandServer(event);
             return true;
         }
         return false;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             // something else is getting the events
             return false;
         }
         auto touch = input()->touch();
         if (touch->internalPressId() != -1) {
             // already on internal window, ignore further touch points, but filter out
             return true;
         }
         // a new touch point
         seat->setTimestamp(time);
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         touch->setInternalPressId(id);
         // Qt's touch event API is rather complex, let's do fake mouse events instead
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
 
         QEnterEvent enterEvent(m_lastLocalTouchPos, m_lastLocalTouchPos, pos);
         QCoreApplication::sendEvent(internal.data(), &enterEvent);
 
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
 
         QMouseEvent e(QEvent::MouseMove, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         QCoreApplication::instance()->sendEvent(internal.data(), &e);
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
 
         QEvent leaveEvent(QEvent::Leave);
         QCoreApplication::sendEvent(internal.data(), &leaveEvent);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setInternalPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 class DecorationEventFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         const QPointF p = event->globalPos() - decoration->client()->pos();
         switch (event->type()) {
         case QEvent::MouseMove: {
             QHoverEvent e(QEvent::HoverMove, p, p);
             QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
             decoration->client()->processDecorationMove(p.toPoint(), event->globalPos());
             return true;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease: {
             const auto actionResult = performClientMouseAction(event, decoration->client());
             if (actionResult.first) {
                 return actionResult.second;
             }
             QMouseEvent e(event->type(), p, event->globalPos(), event->button(), event->buttons(), event->modifiers());
             e.setAccepted(false);
             QCoreApplication::sendEvent(decoration->decoration(), &e);
             if (!e.isAccepted() && event->type() == QEvent::MouseButtonPress) {
                 decoration->client()->processDecorationButtonPress(&e);
             }
             if (event->type() == QEvent::MouseButtonRelease) {
                 decoration->client()->processDecorationButtonRelease(&e);
             }
             return true;
         }
         default:
             break;
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         if (event->angleDelta().y() != 0) {
             // client window action only on vertical scrolling
             const auto actionResult = performClientWheelAction(event, decoration->client());
             if (actionResult.first) {
                 return actionResult.second;
             }
         }
         const QPointF localPos = event->globalPosF() - decoration->client()->pos();
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta(),
                         delta,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration.data(), &e);
         if (e.isAccepted()) {
             return true;
         }
         if ((orientation == Qt::Vertical) && decoration->client()->titlebarPositionUnderMouse()) {
             decoration->client()->performMouseCommand(options->operationTitlebarMouseWheel(delta * -1),
                                                         event->globalPosF().toPoint());
         }
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         if (input()->touch()->decorationPressId() != -1) {
             // already on a decoration, ignore further touch points, but filter out
             return true;
         }
         seat->setTimestamp(time);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
 
         input()->touch()->setDecorationPressId(id);
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
 
         QHoverEvent hoverEvent(QEvent::HoverMove, m_lastLocalTouchPos, m_lastLocalTouchPos);
         QCoreApplication::sendEvent(decoration->decoration(), &hoverEvent);
 
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         if (!e.isAccepted()) {
             decoration->client()->processDecorationButtonPress(&e);
         }
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
 
         QHoverEvent e(QEvent::HoverMove, m_lastLocalTouchPos, m_lastLocalTouchPos);
         QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationMove(m_lastLocalTouchPos.toPoint(), pos.toPoint());
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
 
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationButtonRelease(&e);
 
         QHoverEvent leaveEvent(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::sendEvent(decoration->decoration(), &leaveEvent);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setDecorationPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 #ifdef KWIN_BUILD_TABBOX
 class TabBoxInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 button) override {
         Q_UNUSED(button)
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleMouseEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setFocusedKeyboardSurface(nullptr);
         input()->pointer()->setEnableConstraints(false);
         // pass the key event to the seat, so that it has a proper model of the currently hold keys
         // this is important for combinations like alt+shift to ensure that shift is not considered pressed
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             TabBox::TabBox::self()->keyPress(event->modifiers() | event->key());
         } else if (static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts() == Qt::NoModifier) {
             TabBox::TabBox::self()->modifiersReleased();
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleWheelEvent(event);
     }
 };
 #endif
 
 class ScreenEdgeInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         ScreenEdges::self()->isEntered(event);
         // always forward
         return false;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         // TODO: better check whether a touch sequence is in progress
         if (m_touchInProgress || waylandServer()->seat()->isTouchSequence()) {
             // cancel existing touch
             ScreenEdges::self()->gestureRecognizer()->cancelSwipeGesture();
             m_touchInProgress = false;
             m_id = 0;
             return false;
         }
         if (ScreenEdges::self()->gestureRecognizer()->startSwipeGesture(pos) > 0) {
             m_touchInProgress = true;
             m_id = id;
             m_lastPos = pos;
             return true;
         }
         return false;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (m_touchInProgress && m_id == id) {
             ScreenEdges::self()->gestureRecognizer()->updateSwipeGesture(QSizeF(pos.x() - m_lastPos.x(), pos.y() - m_lastPos.y()));
             m_lastPos = pos;
             return true;
         }
         return false;
     }
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         if (m_touchInProgress && m_id == id) {
             ScreenEdges::self()->gestureRecognizer()->endSwipeGesture();
             m_touchInProgress = false;
             return true;
         }
         return false;
     }
 private:
     bool m_touchInProgress = false;
     qint32 m_id = 0;
     QPointF m_lastPos;
 };
 
 /**
  * This filter implements window actions. If the event should not be passed to the
  * current pointer window it will filter out the event
  */
 class WindowActionInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (event->type() != QEvent::MouseButtonPress) {
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->focus().data());
         if (!c) {
             return false;
         }
         const auto actionResult = performClientMouseAction(event, c, MouseAction::ModifierAndWindow);
         if (actionResult.first) {
             return actionResult.second;
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->angleDelta().y() == 0) {
             // only actions on vertical scroll
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->focus().data());
         if (!c) {
             return false;
         }
         const auto actionResult = performClientWheelAction(event, c, MouseAction::ModifierAndWindow);
         if (actionResult.first) {
             return actionResult.second;
         }
         return false;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(id)
         Q_UNUSED(time)
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->touch()->focus().data());
         if (!c) {
             return false;
         }
         bool wasAction = false;
         const Options::MouseCommand command = c->getMouseCommand(Qt::LeftButton, &wasAction);
         if (wasAction) {
             return !c->performMouseCommand(command, pos.toPoint());
         }
         return false;
     }
 };
 
 /**
  * The remaining default input filter which forwards events to other windows
  */
 class ForwardInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             seat->setPointerPos(event->globalPos());
             MouseEvent *e = static_cast<MouseEvent*>(event);
             if (e->delta() != QSizeF()) {
                 seat->relativePointerMotion(e->delta(), e->deltaUnaccelerated(), e->timestampMicroseconds());
             }
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         auto _event = static_cast<WheelEvent *>(event);
         KWayland::Server::PointerAxisSource source;
         switch (_event->axisSource()) {
         case KWin::InputRedirection::PointerAxisSourceWheel:
             source = KWayland::Server::PointerAxisSource::Wheel;
             break;
         case KWin::InputRedirection::PointerAxisSourceFinger:
             source = KWayland::Server::PointerAxisSource::Finger;
             break;
         case KWin::InputRedirection::PointerAxisSourceContinuous:
             source = KWayland::Server::PointerAxisSource::Continuous;
             break;
         case KWin::InputRedirection::PointerAxisSourceWheelTilt:
             source = KWayland::Server::PointerAxisSource::WheelTilt;
             break;
         case KWin::InputRedirection::PointerAxisSourceUnknown:
         default:
             source = KWayland::Server::PointerAxisSource::Unknown;
             break;
         }
         seat->pointerAxisV5(_event->orientation(), _event->delta(), _event->discreteDelta(), source);
         return true;
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!workspace()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // handled by Wayland client
             return false;
         }
         auto seat = waylandServer()->seat();
         input()->keyboard()->update();
         seat->setTimestamp(event->timestamp());
         passToWaylandServer(event);
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         input()->touch()->insertId(id, seat->touchDown(pos));
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchMove(kwaylandId, pos);
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchUp(kwaylandId);
             input()->touch()->removeId(id);
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerPinchGesture(fingerCount);
         return true;
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerPinchGesture(delta, scale, angleDelta);
         return true;
     }
     bool pinchGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerPinchGesture();
         return true;
     }
     bool pinchGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerPinchGesture();
         return true;
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerSwipeGesture(fingerCount);
         return true;
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerSwipeGesture(delta);
         return true;
     }
     bool swipeGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerSwipeGesture();
         return true;
     }
     bool swipeGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerSwipeGesture();
         return true;
     }
 };
 
 /**
  * Useful when there's no proper tablet support on the clients
  */
 class FakeTabletInputFilter : public InputEventFilter
 {
 public:
     FakeTabletInputFilter()
     {
     }
 
     bool tabletToolEvent(QTabletEvent *event) override
     {
         if (!workspace()) {
             return false;
         }
 
         switch (event->type()) {
         case QEvent::TabletMove:
         case QEvent::TabletEnterProximity:
             input()->pointer()->processMotion(event->globalPosF(), event->timestamp());
             break;
         case QEvent::TabletPress:
             input()->pointer()->processButton(KWin::qtMouseButtonToButton(Qt::LeftButton),
                                               InputRedirection::PointerButtonPressed, event->timestamp());
             break;
         case QEvent::TabletRelease:
             input()->pointer()->processButton(KWin::qtMouseButtonToButton(Qt::LeftButton),
                                               InputRedirection::PointerButtonReleased, event->timestamp());
             break;
         case QEvent::TabletLeaveProximity:
             break;
         default:
             qCWarning(KWIN_CORE) << "Unexpected tablet event type" << event;
             break;
         }
         waylandServer()->simulateUserActivity();
         return true;
     }
 };
 
 class DragAndDropInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         if (!seat->isDragPointer()) {
             return false;
         }
         if (seat->isDragTouch()) {
             return true;
         }
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             const auto pos = input()->globalPointer();
             seat->setPointerPos(pos);
 
             const auto eventPos = event->globalPos();
             // TODO: use InputDeviceHandler::at() here and check isClient()?
             Toplevel *t = input()->findManagedToplevel(eventPos);
             if (auto *xwl = xwayland()) {
                 const auto ret = xwl->dragMoveFilter(t, eventPos);
                 if (ret == Xwl::DragEventReply::Ignore) {
                     return false;
                 } else if (ret == Xwl::DragEventReply::Take) {
                     break;
                 }
             }
 
             if (t) {
                 // TODO: consider decorations
                 if (t->surface() != seat->dragSurface()) {
                     if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
                         workspace()->activateClient(c);
                     }
                     seat->setDragTarget(t->surface(), t->inputTransformation());
                 }
             } else {
                 // no window at that place, if we have a surface we need to reset
                 seat->setDragTarget(nullptr);
             }
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             break;
         default:
             break;
         }
         // TODO: should we pass through effects?
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isDragPointer()) {
             return true;
         }
         if (!seat->isDragTouch()) {
             return false;
         }
         if (m_touchId != id) {
             return true;
         }
         seat->setTimestamp(time);
         input()->touch()->insertId(id, seat->touchDown(pos));
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isDragPointer()) {
             return true;
         }
         if (!seat->isDragTouch()) {
             return false;
         }
         if (m_touchId < 0) {
             // We take for now the first id appearing as a move after a drag
             // started. We can optimize by specifying the id the drag is
             // associated with by implementing a key-value getter in KWayland.
             m_touchId = id;
         }
         if (m_touchId != id) {
             return true;
         }
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId == -1) {
             return true;
         }
 
         seat->touchMove(kwaylandId, pos);
 
         if (Toplevel *t = input()->findToplevel(pos.toPoint())) {
             // TODO: consider decorations
             if (t->surface() != seat->dragSurface()) {
                 if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
                     workspace()->activateClient(c);
                 }
                 seat->setDragTarget(t->surface(), pos, t->inputTransformation());
             }
         } else {
             // no window at that place, if we have a surface we need to reset
             seat->setDragTarget(nullptr);
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (!seat->isDragTouch()) {
             return false;
         }
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchUp(kwaylandId);
             input()->touch()->removeId(id);
         }
         if (m_touchId == id) {
             m_touchId = -1;
         }
         return true;
     }
 private:
     qint32 m_touchId = -1;
 };
 
 KWIN_SINGLETON_FACTORY(InputRedirection)
 
 static const QString s_touchpadComponent = QStringLiteral("kcm_touchpad");
 
 InputRedirection::InputRedirection(QObject *parent)
     : QObject(parent)
     , m_keyboard(new KeyboardInputRedirection(this))
     , m_pointer(new PointerInputRedirection(this))
     , m_tablet(new TabletInputRedirection(this))
     , m_touch(new TouchInputRedirection(this))
     , m_shortcuts(new GlobalShortcutsManager(this))
 {
     qRegisterMetaType<KWin::InputRedirection::KeyboardKeyState>();
     qRegisterMetaType<KWin::InputRedirection::PointerButtonState>();
     qRegisterMetaType<KWin::InputRedirection::PointerAxis>();
     if (Application::usesLibinput()) {
         if (LogindIntegration::self()->hasSessionControl()) {
             setupLibInput();
         } else {
             LibInput::Connection::createThread();
             if (LogindIntegration::self()->isConnected()) {
                 LogindIntegration::self()->takeControl();
             } else {
                 connect(LogindIntegration::self(), &LogindIntegration::connectedChanged, LogindIntegration::self(), &LogindIntegration::takeControl);
             }
             connect(LogindIntegration::self(), &LogindIntegration::hasSessionControlChanged, this,
                 [this] (bool sessionControl) {
                     if (sessionControl) {
                         setupLibInput();
                     }
                 }
             );
         }
     }
     connect(kwinApp(), &Application::workspaceCreated, this, &InputRedirection::setupWorkspace);
     reconfigure();
 }
 
 InputRedirection::~InputRedirection()
 {
     s_self = nullptr;
     qDeleteAll(m_filters);
     qDeleteAll(m_spies);
 }
 
 void InputRedirection::installInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters << filter;
 }
 
 void InputRedirection::prependInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters.prepend(filter);
 }
 
 void InputRedirection::uninstallInputEventFilter(InputEventFilter *filter)
 {
     m_filters.removeOne(filter);
 }
 
 void InputRedirection::installInputEventSpy(InputEventSpy *spy)
 {
     m_spies << spy;
 }
 
 void InputRedirection::uninstallInputEventSpy(InputEventSpy *spy)
 {
     m_spies.removeOne(spy);
 }
 
 void InputRedirection::init()
 {
     m_shortcuts->init();
 }
 
 void InputRedirection::setupWorkspace()
 {
     if (waylandServer()) {
         using namespace KWayland::Server;
         FakeInputInterface *fakeInput = waylandServer()->display()->createFakeInput(this);
         fakeInput->create();
         connect(fakeInput, &FakeInputInterface::deviceCreated, this,
             [this] (FakeInputDevice *device) {
                 connect(device, &FakeInputDevice::authenticationRequested, this,
                     [this, device] (const QString &application, const QString &reason) {
                         Q_UNUSED(application)
                         Q_UNUSED(reason)
                         // TODO: make secure
                         device->setAuthentication(true);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerMotionRequested, this,
                     [this] (const QSizeF &delta) {
                         // TODO: Fix time
                         m_pointer->processMotion(globalPointer() + QPointF(delta.width(), delta.height()), 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                connect(device, &FakeInputDevice::pointerMotionAbsoluteRequested, this,
                     [this] (const QPointF &pos) {
                         // TODO: Fix time
                         m_pointer->processMotion(pos, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonPressRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonPressed, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonReleaseRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonReleased, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerAxisRequested, this,
                     [this] (Qt::Orientation orientation, qreal delta) {
                         // TODO: Fix time
                         InputRedirection::PointerAxis axis;
                         switch (orientation) {
                         case Qt::Horizontal:
                             axis = InputRedirection::PointerAxisHorizontal;
                             break;
                         case Qt::Vertical:
                             axis = InputRedirection::PointerAxisVertical;
                             break;
                         default:
                             Q_UNREACHABLE();
                             break;
                         }
                         // TODO: Fix time
                         m_pointer->processAxis(axis, delta, 0, InputRedirection::PointerAxisSourceUnknown, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::touchDownRequested, this,
                    [this] (qint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processDown(id, pos, 0);
                         waylandServer()->simulateUserActivity();
                    }
                 );
                 connect(device, &FakeInputDevice::touchMotionRequested, this,
                    [this] (qint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processMotion(id, pos, 0);
                         waylandServer()->simulateUserActivity();
                    }
                 );
                 connect(device, &FakeInputDevice::touchUpRequested, this,
                     [this] (qint32 id) {
                         // TODO: Fix time
                         m_touch->processUp(id, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::touchCancelRequested, this,
                     [this] () {
                         m_touch->cancel();
                     }
                 );
                 connect(device, &FakeInputDevice::touchFrameRequested, this,
                    [this] () {
                        m_touch->frame();
                    }
                 );
                 connect(device, &FakeInputDevice::keyboardKeyPressRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_keyboard->processKey(button, InputRedirection::KeyboardKeyPressed, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::keyboardKeyReleaseRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_keyboard->processKey(button, InputRedirection::KeyboardKeyReleased, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
             }
         );
         connect(workspace(), &Workspace::configChanged, this, &InputRedirection::reconfigure);
 
         m_keyboard->init();
         m_pointer->init();
         m_touch->init();
         m_tablet->init();
     }
     setupInputFilters();
 }
 
 void InputRedirection::setupInputFilters()
 {
     const bool hasGlobalShortcutSupport = !waylandServer() || waylandServer()->hasGlobalShortcutSupport();
     if (LogindIntegration::self()->hasSessionControl() && hasGlobalShortcutSupport) {
         installInputEventFilter(new VirtualTerminalFilter);
     }
     if (waylandServer()) {
         installInputEventSpy(new TouchHideCursorSpy);
         if (hasGlobalShortcutSupport) {
             installInputEventFilter(new TerminateServerFilter);
         }
         installInputEventFilter(new DragAndDropInputFilter);
         installInputEventFilter(new LockScreenFilter);
         installInputEventFilter(new PopupInputFilter);
         m_windowSelector = new WindowSelectorFilter;
         installInputEventFilter(m_windowSelector);
     }
     if (hasGlobalShortcutSupport) {
         installInputEventFilter(new ScreenEdgeInputFilter);
     }
     installInputEventFilter(new EffectsFilter);
     installInputEventFilter(new MoveResizeFilter);
 #ifdef KWIN_BUILD_TABBOX
     installInputEventFilter(new TabBoxInputFilter);
 #endif
     if (hasGlobalShortcutSupport) {
         installInputEventFilter(new GlobalShortcutFilter);
     }
     installInputEventFilter(new DecorationEventFilter);
     installInputEventFilter(new InternalWindowEventFilter);
     if (waylandServer()) {
         installInputEventFilter(new WindowActionInputFilter);
         installInputEventFilter(new ForwardInputFilter);
         installInputEventFilter(new FakeTabletInputFilter);
     }
 }
 
 void InputRedirection::reconfigure()
 {
     if (Application::usesLibinput()) {
         auto inputConfig = kwinApp()->inputConfig();
         inputConfig->reparseConfiguration();
         const auto config = inputConfig->group(QStringLiteral("Keyboard"));
         const int delay = config.readEntry("RepeatDelay", 660);
         const int rate = config.readEntry("RepeatRate", 25);
         const bool enabled = config.readEntry("KeyboardRepeating", 0) == 0;
 
         waylandServer()->seat()->setKeyRepeatInfo(enabled ? rate : 0, delay);
     }
 }
 
 static KWayland::Server::SeatInterface *findSeat()
 {
     auto server = waylandServer();
     if (!server) {
         return nullptr;
     }
     return server->seat();
 }
 
 void InputRedirection::setupLibInput()
 {
     if (!Application::usesLibinput()) {
         return;
     }
     if (m_libInput) {
         return;
     }
     LibInput::Connection *conn = LibInput::Connection::create(this);
     m_libInput = conn;
     if (conn) {
 
         if (waylandServer()) {
             // create relative pointer manager
             waylandServer()->display()->createRelativePointerManager(KWayland::Server::RelativePointerInterfaceVersion::UnstableV1, waylandServer()->display())->create();
         }
 
         conn->setInputConfig(kwinApp()->inputConfig());
         conn->updateLEDs(m_keyboard->xkb()->leds());
         waylandServer()->updateKeyState(m_keyboard->xkb()->leds());
         connect(m_keyboard, &KeyboardInputRedirection::ledsChanged, waylandServer(), &WaylandServer::updateKeyState);
         connect(m_keyboard, &KeyboardInputRedirection::ledsChanged, conn, &LibInput::Connection::updateLEDs);
         connect(conn, &LibInput::Connection::eventsRead, this,
             [this] {
                 m_libInput->processEvents();
             }, Qt::QueuedConnection
         );
         conn->setup();
         connect(conn, &LibInput::Connection::pointerButtonChanged, m_pointer, &PointerInputRedirection::processButton);
         connect(conn, &LibInput::Connection::pointerAxisChanged, m_pointer, &PointerInputRedirection::processAxis);
         connect(conn, &LibInput::Connection::pinchGestureBegin, m_pointer, &PointerInputRedirection::processPinchGestureBegin);
         connect(conn, &LibInput::Connection::pinchGestureUpdate, m_pointer, &PointerInputRedirection::processPinchGestureUpdate);
         connect(conn, &LibInput::Connection::pinchGestureEnd, m_pointer, &PointerInputRedirection::processPinchGestureEnd);
         connect(conn, &LibInput::Connection::pinchGestureCancelled, m_pointer, &PointerInputRedirection::processPinchGestureCancelled);
         connect(conn, &LibInput::Connection::swipeGestureBegin, m_pointer, &PointerInputRedirection::processSwipeGestureBegin);
         connect(conn, &LibInput::Connection::swipeGestureUpdate, m_pointer, &PointerInputRedirection::processSwipeGestureUpdate);
         connect(conn, &LibInput::Connection::swipeGestureEnd, m_pointer, &PointerInputRedirection::processSwipeGestureEnd);
         connect(conn, &LibInput::Connection::swipeGestureCancelled, m_pointer, &PointerInputRedirection::processSwipeGestureCancelled);
         connect(conn, &LibInput::Connection::keyChanged, m_keyboard, &KeyboardInputRedirection::processKey);
         connect(conn, &LibInput::Connection::pointerMotion, this,
             [this] (const QSizeF &delta, const QSizeF &deltaNonAccel, uint32_t time, quint64 timeMicroseconds, LibInput::Device *device) {
                 m_pointer->processMotion(m_pointer->pos() + QPointF(delta.width(), delta.height()), delta, deltaNonAccel, time, timeMicroseconds, device);
             }
         );
         connect(conn, &LibInput::Connection::pointerMotionAbsolute, this,
             [this] (QPointF orig, QPointF screen, uint32_t time, LibInput::Device *device) {
                 Q_UNUSED(orig)
                 m_pointer->processMotion(screen, time, device);
             }
         );
         connect(conn, &LibInput::Connection::touchDown, m_touch, &TouchInputRedirection::processDown);
         connect(conn, &LibInput::Connection::touchUp, m_touch, &TouchInputRedirection::processUp);
         connect(conn, &LibInput::Connection::touchMotion, m_touch, &TouchInputRedirection::processMotion);
         connect(conn, &LibInput::Connection::touchCanceled, m_touch, &TouchInputRedirection::cancel);
         connect(conn, &LibInput::Connection::touchFrame, m_touch, &TouchInputRedirection::frame);
         auto handleSwitchEvent = [this] (SwitchEvent::State state, quint32 time, quint64 timeMicroseconds, LibInput::Device *device) {
             SwitchEvent event(state, time, timeMicroseconds, device);
             processSpies(std::bind(&InputEventSpy::switchEvent, std::placeholders::_1, &event));
             processFilters(std::bind(&InputEventFilter::switchEvent, std::placeholders::_1, &event));
         };
         connect(conn, &LibInput::Connection::switchToggledOn, this,
                 std::bind(handleSwitchEvent, SwitchEvent::State::On, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
         connect(conn, &LibInput::Connection::switchToggledOff, this,
                 std::bind(handleSwitchEvent, SwitchEvent::State::Off, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
 
         connect(conn, &LibInput::Connection::tabletToolEvent,
                 m_tablet, &TabletInputRedirection::tabletToolEvent);
         connect(conn, &LibInput::Connection::tabletToolButtonEvent,
                 m_tablet, &TabletInputRedirection::tabletToolButtonEvent);
         connect(conn, &LibInput::Connection::tabletPadButtonEvent,
                 m_tablet, &TabletInputRedirection::tabletPadButtonEvent);
         connect(conn, &LibInput::Connection::tabletPadRingEvent,
                 m_tablet, &TabletInputRedirection::tabletPadRingEvent);
         connect(conn, &LibInput::Connection::tabletPadStripEvent,
                 m_tablet, &TabletInputRedirection::tabletPadStripEvent);
 
         if (screens()) {
             setupLibInputWithScreens();
         } else {
             connect(kwinApp(), &Application::screensCreated, this, &InputRedirection::setupLibInputWithScreens);
         }
         if (auto s = findSeat()) {
             // Workaround for QTBUG-54371: if there is no real keyboard Qt doesn't request virtual keyboard
             s->setHasKeyboard(true);
             s->setHasPointer(conn->hasPointer());
             s->setHasTouch(conn->hasTouch());
             connect(conn, &LibInput::Connection::hasAlphaNumericKeyboardChanged, this,
                 [this] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     // TODO: this should update the seat, only workaround for QTBUG-54371
                     emit hasAlphaNumericKeyboardChanged(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasTabletModeSwitchChanged, this,
                 [this] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     emit hasTabletModeSwitchChanged(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasPointerChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasPointer(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasTouchChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasTouch(set);
                 }
             );
         }
         connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, m_libInput,
             [this] (bool active) {
                 if (!active) {
                     m_libInput->deactivate();
                 }
             }
         );
     }
     setupTouchpadShortcuts();
 }
 
 void InputRedirection::setupTouchpadShortcuts()
 {
     if (!m_libInput) {
         return;
     }
     QAction *touchpadToggleAction = new QAction(this);
     QAction *touchpadOnAction = new QAction(this);
     QAction *touchpadOffAction = new QAction(this);
 
     touchpadToggleAction->setObjectName(QStringLiteral("Toggle Touchpad"));
     touchpadToggleAction->setProperty("componentName", s_touchpadComponent);
     touchpadOnAction->setObjectName(QStringLiteral("Enable Touchpad"));
     touchpadOnAction->setProperty("componentName", s_touchpadComponent);
     touchpadOffAction->setObjectName(QStringLiteral("Disable Touchpad"));
     touchpadOffAction->setProperty("componentName", s_touchpadComponent);
     KGlobalAccel::self()->setDefaultShortcut(touchpadToggleAction, QList<QKeySequence>{Qt::Key_TouchpadToggle});
     KGlobalAccel::self()->setShortcut(touchpadToggleAction, QList<QKeySequence>{Qt::Key_TouchpadToggle});
     KGlobalAccel::self()->setDefaultShortcut(touchpadOnAction, QList<QKeySequence>{Qt::Key_TouchpadOn});
     KGlobalAccel::self()->setShortcut(touchpadOnAction, QList<QKeySequence>{Qt::Key_TouchpadOn});
     KGlobalAccel::self()->setDefaultShortcut(touchpadOffAction, QList<QKeySequence>{Qt::Key_TouchpadOff});
     KGlobalAccel::self()->setShortcut(touchpadOffAction, QList<QKeySequence>{Qt::Key_TouchpadOff});
 #ifndef KWIN_BUILD_TESTING
     registerShortcut(Qt::Key_TouchpadToggle, touchpadToggleAction);
     registerShortcut(Qt::Key_TouchpadOn, touchpadOnAction);
     registerShortcut(Qt::Key_TouchpadOff, touchpadOffAction);
 #endif
     connect(touchpadToggleAction, &QAction::triggered, m_libInput, &LibInput::Connection::toggleTouchpads);
     connect(touchpadOnAction, &QAction::triggered, m_libInput, &LibInput::Connection::enableTouchpads);
     connect(touchpadOffAction, &QAction::triggered, m_libInput, &LibInput::Connection::disableTouchpads);
 }
 
 bool InputRedirection::hasAlphaNumericKeyboard()
 {
     if (m_libInput) {
         return m_libInput->hasAlphaNumericKeyboard();
     }
     return true;
 }
 
 bool InputRedirection::hasTabletModeSwitch()
 {
     if (m_libInput) {
         return m_libInput->hasTabletModeSwitch();
     }
     return false;
 }
 
 void InputRedirection::setupLibInputWithScreens()
 {
     if (!screens() || !m_libInput) {
         return;
     }
     m_libInput->setScreenSize(screens()->size());
     m_libInput->updateScreens();
     connect(screens(), &Screens::sizeChanged, this,
         [this] {
             m_libInput->setScreenSize(screens()->size());
         }
     );
     connect(screens(), &Screens::changed, m_libInput, &LibInput::Connection::updateScreens);
 }
 
 void InputRedirection::processPointerMotion(const QPointF &pos, uint32_t time)
 {
     m_pointer->processMotion(pos, time);
 }
 
 void InputRedirection::processPointerButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time)
 {
     m_pointer->processButton(button, state, time);
 }
 
 void InputRedirection::processPointerAxis(InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta, PointerAxisSource source, uint32_t time)
 {
     m_pointer->processAxis(axis, delta, discreteDelta, source, time);
 }
 
 void InputRedirection::processKeyboardKey(uint32_t key, InputRedirection::KeyboardKeyState state, uint32_t time)
 {
     m_keyboard->processKey(key, state, time);
 }
 
 void InputRedirection::processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     m_keyboard->processModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void InputRedirection::processKeymapChange(int fd, uint32_t size)
 {
     m_keyboard->processKeymapChange(fd, size);
 }
 
 void InputRedirection::processTouchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processDown(id, pos, time);
 }
 
 void InputRedirection::processTouchUp(qint32 id, quint32 time)
 {
     m_touch->processUp(id, time);
 }
 
 void InputRedirection::processTouchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processMotion(id, pos, time);
 }
 
 void InputRedirection::cancelTouch()
 {
     m_touch->cancel();
 }
 
 void InputRedirection::touchFrame()
 {
     m_touch->frame();
 }
 
 Qt::MouseButtons InputRedirection::qtButtonStates() const
 {
     return m_pointer->buttons();
 }
 
 static bool acceptsInput(Toplevel *t, const QPoint &pos)
 {
     const QRegion input = t->inputShape();
     if (input.isEmpty()) {
         return true;
     }
     // TODO: What about sub-surfaces sticking outside the main surface?
     const QPoint localPoint = pos - t->bufferGeometry().topLeft();
     return input.contains(localPoint);
 }
 
 Toplevel *InputRedirection::findToplevel(const QPoint &pos)
 {
     if (!Workspace::self()) {
         return nullptr;
     }
     const bool isScreenLocked = waylandServer() && waylandServer()->isScreenLocked();
     // TODO: check whether the unmanaged wants input events at all
     if (!isScreenLocked) {
         // if an effect overrides the cursor we don't have a window to focus
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
             return nullptr;
         }
         const QList<Unmanaged *> &unmanaged = Workspace::self()->unmanagedList();
         foreach (Unmanaged *u, unmanaged) {
             if (u->inputGeometry().contains(pos) && acceptsInput(u, pos)) {
                 return u;
             }
         }
     }
     return findManagedToplevel(pos);
 }
 
 Toplevel *InputRedirection::findManagedToplevel(const QPoint &pos)
 {
     if (!Workspace::self()) {
         return nullptr;
     }
     const bool isScreenLocked = waylandServer() && waylandServer()->isScreenLocked();
     const QList<Toplevel *> &stacking = Workspace::self()->stackingOrder();
     if (stacking.isEmpty()) {
         return nullptr;
     }
     auto it = stacking.end();
     do {
         --it;
         Toplevel *t = (*it);
         if (t->isDeleted()) {
             // a deleted window doesn't get mouse events
             continue;
         }
         if (AbstractClient *c = dynamic_cast<AbstractClient*>(t)) {
             if (!c->isOnCurrentActivity() || !c->isOnCurrentDesktop() || c->isMinimized() || c->isHiddenInternal()) {
                 continue;
             }
         }
         if (!t->readyForPainting()) {
             continue;
         }
         if (isScreenLocked) {
             if (!t->isLockScreen() && !t->isInputMethod()) {
                 continue;
             }
         }
         if (t->inputGeometry().contains(pos) && acceptsInput(t, pos)) {
             return t;
         }
     } while (it != stacking.begin());
     return nullptr;
 }
 
 Qt::KeyboardModifiers InputRedirection::keyboardModifiers() const
 {
     return m_keyboard->modifiers();
 }
 
 Qt::KeyboardModifiers InputRedirection::modifiersRelevantForGlobalShortcuts() const
 {
     return m_keyboard->modifiersRelevantForGlobalShortcuts();
 }
 
 void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action)
 {
     Q_UNUSED(shortcut)
     kwinApp()->platform()->setupActionForGlobalAccel(action);
 }
 
 void InputRedirection::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     m_shortcuts->registerPointerShortcut(action, modifiers, pointerButtons);
 }
 
 void InputRedirection::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     m_shortcuts->registerAxisShortcut(action, modifiers, axis);
 }
 
 void InputRedirection::registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action)
 {
     m_shortcuts->registerTouchpadSwipe(action, direction);
 }
 
 void InputRedirection::registerGlobalAccel(KGlobalAccelInterface *interface)
 {
     m_shortcuts->setKGlobalAccelInterface(interface);
 }
 
 void InputRedirection::warpPointer(const QPointF &pos)
 {
     m_pointer->warp(pos);
 }
 
 bool InputRedirection::supportsPointerWarping() const
 {
     return m_pointer->supportsWarping();
 }
 
 QPointF InputRedirection::globalPointer() const
 {
     return m_pointer->pos();
 }
 
 void InputRedirection::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!m_windowSelector || m_windowSelector->isActive()) {
         callback(nullptr);
         return;
     }
     m_windowSelector->start(callback);
     m_pointer->setWindowSelectionCursor(cursorName);
 }
 
 void InputRedirection::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
 {
     if (!m_windowSelector || m_windowSelector->isActive()) {
         callback(QPoint(-1, -1));
         return;
     }
     m_windowSelector->start(callback);
     m_pointer->setWindowSelectionCursor(QByteArray());
 }
 
 bool InputRedirection::isSelectingWindow() const
 {
     return m_windowSelector ? m_windowSelector->isActive() : false;
 }
 
 InputDeviceHandler::InputDeviceHandler(InputRedirection *input)
     : QObject(input)
 {
 }
 
 InputDeviceHandler::~InputDeviceHandler() = default;
 
 void InputDeviceHandler::init()
 {
     connect(workspace(), &Workspace::stackingOrderChanged, this, &InputDeviceHandler::update);
     connect(workspace(), &Workspace::clientMinimizedChanged, this, &InputDeviceHandler::update);
     connect(VirtualDesktopManager::self(), &VirtualDesktopManager::currentChanged, this, &InputDeviceHandler::update);
 }
 
 bool InputDeviceHandler::setAt(Toplevel *toplevel)
 {
     if (m_at.at == toplevel) {
         return false;
     }
     auto old = m_at.at;
     disconnect(m_at.surfaceCreatedConnection);
     m_at.surfaceCreatedConnection = QMetaObject::Connection();
 
     m_at.at = toplevel;
     emit atChanged(old, toplevel);
     return true;
 }
 
 void InputDeviceHandler::setFocus(Toplevel *toplevel)
 {
     m_focus.focus = toplevel;
     //TODO: call focusUpdate?
 }
 
 void InputDeviceHandler::setDecoration(QPointer<Decoration::DecoratedClientImpl> decoration)
 {
     auto oldDeco = m_focus.decoration;
     m_focus.decoration = decoration;
     cleanupDecoration(oldDeco.data(), m_focus.decoration.data());
     emit decorationChanged();
 }
 
 void InputDeviceHandler::setInternalWindow(QWindow *window)
 {
     m_focus.internalWindow = window;
     //TODO: call internalWindowUpdate?
 }
 
 void InputDeviceHandler::updateFocus()
 {
     auto oldFocus = m_focus.focus;
 
     if (m_at.at && !m_at.at->surface()) {
         // The surface has not yet been created (special XWayland case).
         // Therefore listen for its creation.
         if (!m_at.surfaceCreatedConnection) {
             m_at.surfaceCreatedConnection = connect(m_at.at, &Toplevel::surfaceChanged,
                                                     this, &InputDeviceHandler::update);
         }
         m_focus.focus = nullptr;
     } else {
         m_focus.focus = m_at.at;
     }
 
     focusUpdate(oldFocus, m_focus.focus);
 }
 
 bool InputDeviceHandler::updateDecoration()
 {
     const auto oldDeco = m_focus.decoration;
     m_focus.decoration = nullptr;
 
     auto *ac = qobject_cast<AbstractClient*>(m_at.at);
     if (ac && ac->decoratedClient()) {
         const QRect clientRect = QRect(ac->clientPos(), ac->clientSize()).translated(ac->pos());
         if (!clientRect.contains(position().toPoint())) {
             // input device above decoration
             m_focus.decoration = ac->decoratedClient();
         }
     }
 
     if (m_focus.decoration == oldDeco) {
         // no change to decoration
         return false;
     }
     cleanupDecoration(oldDeco.data(), m_focus.decoration.data());
     emit decorationChanged();
     return true;
 }
 
 void InputDeviceHandler::updateInternalWindow(QWindow *window)
 {
     if (m_focus.internalWindow == window) {
         // no change
         return;
     }
     const auto oldInternal = m_focus.internalWindow;
     m_focus.internalWindow = window;
     cleanupInternalWindow(oldInternal, window);
 }
 
 void InputDeviceHandler::update()
 {
     if (!m_inited) {
         return;
     }
 
     Toplevel *toplevel = nullptr;
     QWindow *internalWindow = nullptr;
 
     if (!positionValid()) {
         const auto pos = position().toPoint();
         internalWindow = findInternalWindow(pos);
         if (internalWindow) {
             toplevel = workspace()->findInternal(internalWindow);
         } else {
             toplevel = input()->findToplevel(pos);
         }
     }
     // Always set the toplevel at the position of the input device.
     setAt(toplevel);
 
     if (focusUpdatesBlocked()) {
         return;
     }
 
     if (internalWindow) {
         if (m_focus.internalWindow != internalWindow) {
             // changed internal window
             updateDecoration();
             updateInternalWindow(internalWindow);
             updateFocus();
         } else if (updateDecoration()) {
             // went onto or off from decoration, update focus
             updateFocus();
         }
         return;
     }
     updateInternalWindow(nullptr);
 
     if (m_focus.focus != m_at.at) {
         // focus change
         updateDecoration();
         updateFocus();
         return;
     }
     // check if switched to/from decoration while staying on the same Toplevel
     if (updateDecoration()) {
         // went onto or off from decoration, update focus
         updateFocus();
     }
 }
 
 QWindow* InputDeviceHandler::findInternalWindow(const QPoint &pos) const
 {
     if (waylandServer()->isScreenLocked()) {
         return nullptr;
     }
 
     const QList<InternalClient *> &internalClients = workspace()->internalClients();
     if (internalClients.isEmpty()) {
         return nullptr;
     }
 
     auto it = internalClients.end();
     do {
         --it;
         QWindow *w = (*it)->internalWindow();
         if (!w || !w->isVisible()) {
             continue;
         }
         if (!(*it)->frameGeometry().contains(pos)) {
             continue;
         }
         // check input mask
         const QRegion mask = w->mask().translated(w->geometry().topLeft());
         if (!mask.isEmpty() && !mask.contains(pos)) {
             continue;
         }
         if (w->property("outputOnly").toBool()) {
             continue;
         }
         return w;
     } while (it != internalClients.begin());
 
     return nullptr;
 }
 
 } // namespace
diff --git a/layers.cpp b/layers.cpp
index 3b68f84d2..4a5b17fb0 100644
--- a/layers.cpp
+++ b/layers.cpp
@@ -1,865 +1,864 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 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/>.
 *********************************************************************/
 
 // SELI zmenit doc
 
 /*
 
  This file contains things relevant to stacking order and layers.
 
  Design:
 
  Normal unconstrained stacking order, as requested by the user (by clicking
  on windows to raise them, etc.), is in Workspace::unconstrained_stacking_order.
  That list shouldn't be used at all, except for building
  Workspace::stacking_order. The building is done
  in Workspace::constrainedStackingOrder(). Only Workspace::stackingOrder() should
  be used to get the stacking order, because it also checks the stacking order
  is up to date.
  All clients are also stored in Workspace::clients (except for isDesktop() clients,
  as those are very special, and are stored in Workspace::desktops), in the order
  the clients were created.
 
  Every window has one layer assigned in which it is. There are 7 layers,
  from bottom : DesktopLayer, BelowLayer, NormalLayer, DockLayer, AboveLayer, NotificationLayer,
  ActiveLayer, CriticalNotificationLayer, and OnScreenDisplayLayer (see also NETWM sect.7.10.).
  The layer a window is in depends on the window type, and on other things like whether the window
  is active. We extend the layers provided in NETWM by the NotificationLayer, OnScreenDisplayLayer,
  and CriticalNotificationLayer.
  The NoficationLayer contains notification windows which are kept above all windows except the active
  fullscreen window. The CriticalNotificationLayer contains notification windows which are important
  enough to keep them even above fullscreen windows. The OnScreenDisplayLayer is used for eg. volume
  and brightness change feedback and is kept above all windows since it provides immediate response
  to a user action.
 
  NET::Splash clients belong to the Normal layer. NET::TopMenu clients
  belong to Dock layer. Clients that are both NET::Dock and NET::KeepBelow
  are in the Normal layer in order to keep the 'allow window to cover
  the panel' Kicker setting to work as intended (this may look like a slight
  spec violation, but a) I have no better idea, b) the spec allows adjusting
  the stacking order if the WM thinks it's a good idea . We put all
  NET::KeepAbove above all Docks too, even though the spec suggests putting
  them in the same layer.
 
  Most transients are in the same layer as their mainwindow,
  see Workspace::constrainedStackingOrder(), they may also be in higher layers, but
  they should never be below their mainwindow.
 
  When some client attribute changes (above/below flag, transiency...),
  Workspace::updateClientLayer() should be called in order to make
  sure it's moved to the appropriate layer QList<X11Client *> if needed.
 
  Currently the things that affect client in which layer a client
  belongs: KeepAbove/Keep Below flags, window type, fullscreen
  state and whether the client is active, mainclient (transiency).
 
  Make sure updateStackingOrder() is called in order to make
  Workspace::stackingOrder() up to date and propagated to the world.
  Using Workspace::blockStackingUpdates() (or the StackingUpdatesBlocker
  helper class) it's possible to temporarily disable updates
  and the stacking order will be updated once after it's allowed again.
 
 */
 
 #include "utils.h"
 #include "x11client.h"
 #include "focuschain.h"
 #include "netinfo.h"
 #include "workspace.h"
 #include "tabbox.h"
 #include "group.h"
 #include "rules.h"
 #include "screens.h"
 #include "unmanaged.h"
 #include "deleted.h"
 #include "effects.h"
 #include "composite.h"
 #include "screenedge.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 #include "internal_client.h"
 
 #include <QDebug>
 
 namespace KWin
 {
 
 //*******************************
 // Workspace
 //*******************************
 
 void Workspace::updateClientLayer(AbstractClient* c)
 {
     if (c)
         c->updateLayer();
 }
 
 void Workspace::updateStackingOrder(bool propagate_new_clients)
 {
     if (block_stacking_updates > 0) {
         if (propagate_new_clients)
             blocked_propagating_new_clients = true;
         return;
     }
     QList<Toplevel *> new_stacking_order = constrainedStackingOrder();
     bool changed = (force_restacking || new_stacking_order != stacking_order);
     force_restacking = false;
     stacking_order = new_stacking_order;
     if (changed || propagate_new_clients) {
         propagateClients(propagate_new_clients);
         emit stackingOrderChanged();
         if (m_compositor) {
             m_compositor->addRepaintFull();
         }
 
         if (active_client)
             active_client->updateMouseGrab();
     }
 }
 
 /**
  * Some fullscreen effects have to raise the screenedge on top of an input window, thus all windows
  * this function puts them back where they belong for regular use and is some cheap variant of
  * the regular propagateClients function in that it completely ignores managed clients and everything
  * else and also does not update the NETWM property.
  * Called from Effects::destroyInputWindow so far.
  */
 void Workspace::stackScreenEdgesUnderOverrideRedirect()
 {
     if (!rootInfo()) {
         return;
     }
     Xcb::restackWindows(QVector<xcb_window_t>() << rootInfo()->supportWindow() << ScreenEdges::self()->windows());
 }
 
 /**
  * Propagates the managed clients to the world.
  * Called ONLY from updateStackingOrder().
  */
 void Workspace::propagateClients(bool propagate_new_clients)
 {
     if (!rootInfo()) {
         return;
     }
     // restack the windows according to the stacking order
     // supportWindow > electric borders > clients > hidden clients
     QVector<xcb_window_t> newWindowStack;
 
     // Stack all windows under the support window. The support window is
     // not used for anything (besides the NETWM property), and it's not shown,
     // but it was lowered after kwin startup. Stacking all clients below
     // it ensures that no client will be ever shown above override-redirect
     // windows (e.g. popups).
     newWindowStack << rootInfo()->supportWindow();
 
     newWindowStack << ScreenEdges::self()->windows();
 
     newWindowStack << manual_overlays;
 
     newWindowStack.reserve(newWindowStack.size() + 2*stacking_order.size()); // *2 for inputWindow
 
     for (int i = stacking_order.size() - 1; i >= 0; --i) {
         X11Client *client = qobject_cast<X11Client *>(stacking_order.at(i));
         if (!client || client->hiddenPreview()) {
             continue;
         }
 
         if (client->inputId())
             // Stack the input window above the frame
             newWindowStack << client->inputId();
 
         newWindowStack << client->frameId();
     }
 
     // when having hidden previews, stack hidden windows below everything else
     // (as far as pure X stacking order is concerned), in order to avoid having
     // these windows that should be unmapped to interfere with other windows
     for (int i = stacking_order.size() - 1; i >= 0; --i) {
         X11Client *client = qobject_cast<X11Client *>(stacking_order.at(i));
         if (!client || !client->hiddenPreview())
             continue;
         newWindowStack << client->frameId();
     }
     // TODO isn't it too inefficient to restack always all clients?
     // TODO don't restack not visible windows?
     Q_ASSERT(newWindowStack.at(0) == rootInfo()->supportWindow());
     Xcb::restackWindows(newWindowStack);
 
     int pos = 0;
     xcb_window_t *cl(nullptr);
     if (propagate_new_clients) {
         cl = new xcb_window_t[ manual_overlays.count() + desktops.count() + clients.count()];
         for (const auto win : manual_overlays) {
             cl[pos++] = win;
         }
         // TODO this is still not completely in the map order
         for (auto it = desktops.constBegin(); it != desktops.constEnd(); ++it)
             cl[pos++] = (*it)->window();
         for (auto it = clients.constBegin(); it != clients.constEnd(); ++it)
             cl[pos++] = (*it)->window();
         rootInfo()->setClientList(cl, pos);
         delete [] cl;
     }
 
     cl = new xcb_window_t[ manual_overlays.count() + stacking_order.count()];
     pos = 0;
     for (auto it = stacking_order.constBegin(); it != stacking_order.constEnd(); ++it) {
         X11Client *client = qobject_cast<X11Client *>(*it);
         if (client) {
             cl[pos++] = client->window();
         }
     }
     for (const auto win : manual_overlays) {
         cl[pos++] = win;
     }
     rootInfo()->setClientListStacking(cl, pos);
     delete [] cl;
 
     // Make the cached stacking order invalid here, in case we need the new stacking order before we get
     // the matching event, due to X being asynchronous.
     markXStackingOrderAsDirty();
 }
 
 /**
  * Returns topmost visible client. Windows on the dock, the desktop
  * or of any other special kind are excluded. Also if the window
  * doesn't accept focus it's excluded.
  */
 // TODO misleading name for this method, too many slightly different ways to use it
 AbstractClient* Workspace::topClientOnDesktop(int desktop, int screen, bool unconstrained, bool only_normal) const
 {
 // TODO    Q_ASSERT( block_stacking_updates == 0 );
     QList<Toplevel *> list;
     if (!unconstrained)
         list = stacking_order;
     else
         list = unconstrained_stacking_order;
     for (int i = list.size() - 1;
             i >= 0;
             --i) {
         AbstractClient *c = qobject_cast<AbstractClient*>(list.at(i));
         if (!c) {
             continue;
         }
         if (c->isOnDesktop(desktop) && c->isShown(false) && c->isOnCurrentActivity()) {
             if (screen != -1 && c->screen() != screen)
                 continue;
             if (!only_normal)
                 return c;
             if (c->wantsTabFocus() && !c->isSpecialWindow())
                 return c;
         }
     }
     return nullptr;
 }
 
 AbstractClient* Workspace::findDesktop(bool topmost, int desktop) const
 {
 // TODO    Q_ASSERT( block_stacking_updates == 0 );
     if (topmost) {
         for (int i = stacking_order.size() - 1; i >= 0; i--) {
             AbstractClient *c = qobject_cast<AbstractClient*>(stacking_order.at(i));
             if (c && c->isOnDesktop(desktop) && c->isDesktop()
                     && c->isShown(true))
                 return c;
         }
     } else { // bottom-most
         foreach (Toplevel * c, stacking_order) {
             AbstractClient *client = qobject_cast<AbstractClient*>(c);
             if (client && c->isOnDesktop(desktop) && c->isDesktop()
                     && client->isShown(true))
                 return client;
         }
     }
     return nullptr;
 }
 
 void Workspace::raiseOrLowerClient(AbstractClient *c)
 {
     if (!c) return;
     AbstractClient* topmost = nullptr;
 // TODO    Q_ASSERT( block_stacking_updates == 0 );
     if (most_recently_raised && stacking_order.contains(most_recently_raised) &&
             most_recently_raised->isShown(true) && c->isOnCurrentDesktop())
         topmost = most_recently_raised;
     else
         topmost = topClientOnDesktop(c->isOnAllDesktops() ? VirtualDesktopManager::self()->current() : c->desktop(),
                                      options->isSeparateScreenFocus() ? c->screen() : -1);
 
     if (c == topmost)
         lowerClient(c);
     else
         raiseClient(c);
 }
 
 
 void Workspace::lowerClient(AbstractClient* c, bool nogroup)
 {
     if (!c)
         return;
 
     c->cancelAutoRaise();
 
     StackingUpdatesBlocker blocker(this);
 
     unconstrained_stacking_order.removeAll(c);
     unconstrained_stacking_order.prepend(c);
     if (!nogroup && c->isTransient()) {
         // lower also all windows in the group, in their reversed stacking order
         QList<X11Client *> wins;
         if (auto group = c->group()) {
             wins = ensureStackingOrder(group->members());
         }
         for (int i = wins.size() - 1;
                 i >= 0;
                 --i) {
             if (wins[ i ] != c)
                 lowerClient(wins[ i ], true);
         }
     }
 
     if (c == most_recently_raised)
         most_recently_raised = nullptr;
 }
 
 void Workspace::lowerClientWithinApplication(AbstractClient* c)
 {
     if (!c)
         return;
 
     c->cancelAutoRaise();
 
     StackingUpdatesBlocker blocker(this);
 
     unconstrained_stacking_order.removeAll(c);
     bool lowered = false;
     // first try to put it below the bottom-most window of the application
     for (auto it = unconstrained_stacking_order.begin();
             it != unconstrained_stacking_order.end();
             ++it) {
         AbstractClient *client = qobject_cast<AbstractClient*>(*it);
         if (!client) {
             continue;
         }
         if (AbstractClient::belongToSameApplication(client, c)) {
             unconstrained_stacking_order.insert(it, c);
             lowered = true;
             break;
         }
     }
     if (!lowered)
         unconstrained_stacking_order.prepend(c);
     // ignore mainwindows
 }
 
 void Workspace::raiseClient(AbstractClient* c, bool nogroup)
 {
     if (!c)
         return;
 
     c->cancelAutoRaise();
 
     StackingUpdatesBlocker blocker(this);
 
     if (!nogroup && c->isTransient()) {
         QList<AbstractClient*> transients;
         AbstractClient *transient_parent = c;
         while ((transient_parent = transient_parent->transientFor()))
             transients << transient_parent;
         foreach (transient_parent, transients)
             raiseClient(transient_parent, true);
     }
 
     unconstrained_stacking_order.removeAll(c);
     unconstrained_stacking_order.append(c);
 
     if (!c->isSpecialWindow()) {
         most_recently_raised = c;
     }
 }
 
 void Workspace::raiseClientWithinApplication(AbstractClient* c)
 {
     if (!c)
         return;
 
     c->cancelAutoRaise();
 
     StackingUpdatesBlocker blocker(this);
     // ignore mainwindows
 
     // first try to put it above the top-most window of the application
     for (int i = unconstrained_stacking_order.size() - 1; i > -1 ; --i) {
         AbstractClient *other = qobject_cast<AbstractClient*>(unconstrained_stacking_order.at(i));
         if (!other) {
             continue;
         }
         if (other == c)     // don't lower it just because it asked to be raised
             return;
         if (AbstractClient::belongToSameApplication(other, c)) {
             unconstrained_stacking_order.removeAll(c);
             unconstrained_stacking_order.insert(unconstrained_stacking_order.indexOf(other) + 1, c);   // insert after the found one
             break;
         }
     }
 }
 
 void Workspace::raiseClientRequest(KWin::AbstractClient *c, NET::RequestSource src, xcb_timestamp_t timestamp)
 {
     if (src == NET::FromTool || allowFullClientRaising(c, timestamp))
         raiseClient(c);
     else {
         raiseClientWithinApplication(c);
         c->demandAttention();
     }
 }
 
 void Workspace::lowerClientRequest(KWin::X11Client *c, NET::RequestSource src, xcb_timestamp_t /*timestamp*/)
 {
     // If the client has support for all this focus stealing prevention stuff,
     // do only lowering within the application, as that's the more logical
     // variant of lowering when application requests it.
     // No demanding of attention here of course.
     if (src == NET::FromTool || !c->hasUserTimeSupport())
         lowerClient(c);
     else
         lowerClientWithinApplication(c);
 }
 
 void Workspace::lowerClientRequest(KWin::AbstractClient *c)
 {
     lowerClientWithinApplication(c);
 }
 
 void Workspace::restack(AbstractClient* c, AbstractClient* under, bool force)
 {
     Q_ASSERT(unconstrained_stacking_order.contains(under));
     if (!force && !AbstractClient::belongToSameApplication(under, c)) {
          // put in the stacking order below _all_ windows belonging to the active application
         for (int i = 0; i < unconstrained_stacking_order.size(); ++i) {
             AbstractClient *other = qobject_cast<AbstractClient*>(unconstrained_stacking_order.at(i));
             if (other && other->layer() == c->layer() && AbstractClient::belongToSameApplication(under, other)) {
                 under = (c == other) ? nullptr : other;
                 break;
             }
         }
     }
     if (under) {
         unconstrained_stacking_order.removeAll(c);
         unconstrained_stacking_order.insert(unconstrained_stacking_order.indexOf(under), c);
     }
 
     Q_ASSERT(unconstrained_stacking_order.contains(c));
     FocusChain::self()->moveAfterClient(c, under);
     updateStackingOrder();
 }
 
 void Workspace::restackClientUnderActive(AbstractClient* c)
 {
     if (!active_client || active_client == c || active_client->layer() != c->layer()) {
         raiseClient(c);
         return;
     }
     restack(c, active_client);
 }
 
 void Workspace::restoreSessionStackingOrder(X11Client *c)
 {
     if (c->sessionStackingOrder() < 0)
         return;
     StackingUpdatesBlocker blocker(this);
     unconstrained_stacking_order.removeAll(c);
     for (auto it = unconstrained_stacking_order.begin();  // from bottom
             it != unconstrained_stacking_order.end();
             ++it) {
         X11Client *current = qobject_cast<X11Client *>(*it);
         if (!current) {
             continue;
         }
         if (current->sessionStackingOrder() > c->sessionStackingOrder()) {
             unconstrained_stacking_order.insert(it, c);
             return;
         }
     }
     unconstrained_stacking_order.append(c);
 }
 
 /**
  * Returns a stacking order based upon \a list that fulfills certain contained.
  */
 QList<Toplevel *> Workspace::constrainedStackingOrder()
 {
     QList<Toplevel *> layer[ NumLayers ];
 
     // build the order from layers
     QVector< QMap<Group*, Layer> > minimum_layer(screens()->count());
     for (auto it = unconstrained_stacking_order.constBegin(),
                                   end = unconstrained_stacking_order.constEnd(); it != end; ++it) {
         Layer l = (*it)->layer();
 
         const int screen = (*it)->screen();
         X11Client *c = qobject_cast<X11Client *>(*it);
         QMap< Group*, Layer >::iterator mLayer = minimum_layer[screen].find(c ? c->group() : nullptr);
         if (mLayer != minimum_layer[screen].end()) {
             // If a window is raised above some other window in the same window group
             // which is in the ActiveLayer (i.e. it's fulscreened), make sure it stays
             // above that window (see #95731).
             if (*mLayer == ActiveLayer && (l > BelowLayer))
                 l = ActiveLayer;
             *mLayer = l;
         } else if (c) {
             minimum_layer[screen].insertMulti(c->group(), l);
         }
         layer[ l ].append(*it);
     }
     QList<Toplevel *> stacking;
     for (int lay = FirstLayer; lay < NumLayers; ++lay) {
         stacking += layer[lay];
     }
     // now keep transients above their mainwindows
     // TODO this could(?) use some optimization
     for (int i = stacking.size() - 1; i >= 0;) {
         // Index of the main window for the current transient window.
         int i2 = -1;
 
         // If the current transient has "child" transients, we'd like to restart
         // construction of the constrained stacking order from the position where
         // the current transient will be moved.
         bool hasTransients = false;
 
         // Find topmost client this one is transient for.
         if (auto *client = qobject_cast<AbstractClient *>(stacking[i])) {
             if (!client->isTransient()) {
                 --i;
                 continue;
             }
             for (i2 = stacking.size() - 1; i2 >= 0; --i2) {
                 auto *c2 = qobject_cast<AbstractClient *>(stacking[i2]);
                 if (!c2) {
                     continue;
                 }
                 if (c2 == client) {
                     i2 = -1; // Don't reorder, already on top of its main window.
                     break;
                 }
                 if (c2->hasTransient(client, true)
                         && keepTransientAbove(c2, client)) {
                     break;
                 }
             }
 
             hasTransients = !client->transients().isEmpty();
 
             // If the current transient doesn't have any "alive" transients, check
             // whether it has deleted transients that have to be raised.
             const bool searchForDeletedTransients = !hasTransients
                 && !deletedList().isEmpty();
             if (searchForDeletedTransients) {
                 for (int j = i + 1; j < stacking.count(); ++j) {
                     auto *deleted = qobject_cast<Deleted *>(stacking[j]);
                     if (!deleted) {
                         continue;
                     }
                     if (deleted->wasTransientFor(client)) {
                         hasTransients = true;
                         break;
                     }
                 }
             }
         } else if (auto *deleted = qobject_cast<Deleted *>(stacking[i])) {
             if (!deleted->wasTransient()) {
                 --i;
                 continue;
             }
             for (i2 = stacking.size() - 1; i2 >= 0; --i2) {
                 Toplevel *c2 = stacking[i2];
                 if (c2 == deleted) {
                     i2 = -1; // Don't reorder, already on top of its main window.
                     break;
                 }
                 if (deleted->wasTransientFor(c2)
                         && keepDeletedTransientAbove(c2, deleted)) {
                     break;
                 }
             }
             hasTransients = !deleted->transients().isEmpty();
         }
 
         if (i2 == -1) {
             --i;
             continue;
         }
 
         Toplevel *current = stacking[i];
 
         stacking.removeAt(i);
         --i; // move onto the next item (for next for () iteration)
         --i2; // adjust index of the mainwindow after the remove above
         if (hasTransients) {  // this one now can be possibly above its transients,
             i = i2; // so go again higher in the stack order and possibly move those transients again
         }
         ++i2; // insert after (on top of) the mainwindow, it's ok if it2 is now stacking.end()
         stacking.insert(i2, current);
     }
     return stacking;
 }
 
 void Workspace::blockStackingUpdates(bool block)
 {
     if (block) {
         if (block_stacking_updates == 0)
             blocked_propagating_new_clients = false;
         ++block_stacking_updates;
     } else // !block
         if (--block_stacking_updates == 0) {
             updateStackingOrder(blocked_propagating_new_clients);
             if (effects)
                 static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking();
         }
 }
 
 namespace {
 template <class T>
 QList<T*> ensureStackingOrderInList(const QList<Toplevel *> &stackingOrder, const QList<T*> &list)
 {
     static_assert(std::is_base_of<Toplevel, T>::value,
                  "U must be derived from T");
 // TODO    Q_ASSERT( block_stacking_updates == 0 );
     if (list.count() < 2)
         return list;
     // TODO is this worth optimizing?
     QList<T*> result = list;
     for (auto it = stackingOrder.begin();
             it != stackingOrder.end();
             ++it) {
         T *c = qobject_cast<T*>(*it);
         if (!c) {
             continue;
         }
         if (result.removeAll(c) != 0)
             result.append(c);
     }
     return result;
 }
 }
 
 // Ensure list is in stacking order
 QList<X11Client *> Workspace::ensureStackingOrder(const QList<X11Client *> &list) const
 {
     return ensureStackingOrderInList(stacking_order, list);
 }
 
 QList<AbstractClient*> Workspace::ensureStackingOrder(const QList<AbstractClient*> &list) const
 {
     return ensureStackingOrderInList(stacking_order, list);
 }
 
 // check whether a transient should be actually kept above its mainwindow
 // there may be some special cases where this rule shouldn't be enfored
 bool Workspace::keepTransientAbove(const AbstractClient* mainwindow, const AbstractClient* transient)
 {
     // #93832 - don't keep splashscreens above dialogs
     if (transient->isSplash() && mainwindow->isDialog())
         return false;
     // This is rather a hack for #76026. Don't keep non-modal dialogs above
     // the mainwindow, but only if they're group transient (since only such dialogs
     // have taskbar entry in Kicker). A proper way of doing this (both kwin and kicker)
     // needs to be found.
     if (transient->isDialog() && !transient->isModal() && transient->groupTransient())
         return false;
     // #63223 - don't keep transients above docks, because the dock is kept high,
     // and e.g. dialogs for them would be too high too
     // ignore this if the transient has a placement hint which indicates it should go above it's parent
     if (mainwindow->isDock() && !transient->hasTransientPlacementHint())
         return false;
     return true;
 }
 
 bool Workspace::keepDeletedTransientAbove(const Toplevel *mainWindow, const Deleted *transient) const
 {
     // #93832 - Don't keep splashscreens above dialogs.
     if (transient->isSplash() && mainWindow->isDialog()) {
         return false;
     }
 
     if (transient->wasX11Client()) {
         // If a group transient was active, we should keep it above no matter
         // what, because at the time when the transient was closed, it was above
         // the main window.
         if (transient->wasGroupTransient() && transient->wasActive()) {
             return true;
         }
 
         // This is rather a hack for #76026. Don't keep non-modal dialogs above
         // the mainwindow, but only if they're group transient (since only such
         // dialogs have taskbar entry in Kicker). A proper way of doing this
         // (both kwin and kicker) needs to be found.
         if (transient->wasGroupTransient() && transient->isDialog()
                 && !transient->isModal()) {
             return false;
         }
 
         // #63223 - Don't keep transients above docks, because the dock is kept
         // high, and e.g. dialogs for them would be too high too.
         if (mainWindow->isDock()) {
             return false;
         }
     }
 
     return true;
 }
 
 // Returns all windows in their stacking order on the root window.
 QList<Toplevel *> Workspace::xStackingOrder() const
 {
     if (m_xStackingDirty) {
         const_cast<Workspace*>(this)->updateXStackingOrder();
     }
     return x_stacking;
 }
 
 void Workspace::updateXStackingOrder()
 {
     x_stacking.clear();
     std::unique_ptr<Xcb::Tree> tree{std::move(m_xStackingQueryTree)};
     // use our own stacking order, not the X one, as they may differ
     foreach (Toplevel * c, stacking_order)
     x_stacking.append(c);
 
     if (tree && !tree->isNull()) {
         xcb_window_t *windows = tree->children();
         const auto count = tree->data()->children_len;
         int foundUnmanagedCount = unmanaged.count();
         for (unsigned int i = 0;
                 i < count;
                 ++i) {
             for (auto it = unmanaged.constBegin(); it != unmanaged.constEnd(); ++it) {
                 Unmanaged *u = *it;
                 if (u->window() == windows[i]) {
                     x_stacking.append(u);
                     foundUnmanagedCount--;
                     break;
                 }
             }
             if (foundUnmanagedCount == 0) {
                 break;
             }
         }
     }
 
     for (InternalClient *client : workspace()->internalClients()) {
         if (client->isShown(false)) {
             x_stacking.append(client);
         }
     }
 
     m_xStackingDirty = false;
 }
 
 //*******************************
 // Client
 //*******************************
 
 void X11Client::restackWindow(xcb_window_t above, int detail, NET::RequestSource src, xcb_timestamp_t timestamp, bool send_event)
 {
     X11Client *other = nullptr;
     if (detail == XCB_STACK_MODE_OPPOSITE) {
         other = workspace()->findClient(Predicate::WindowMatch, above);
         if (!other) {
             workspace()->raiseOrLowerClient(this);
             return;
         }
         auto it = workspace()->stackingOrder().constBegin(),
                                     end = workspace()->stackingOrder().constEnd();
         while (it != end) {
             if (*it == this) {
                 detail = XCB_STACK_MODE_ABOVE;
                 break;
             } else if (*it == other) {
                 detail = XCB_STACK_MODE_BELOW;
                 break;
             }
             ++it;
         }
     }
     else if (detail == XCB_STACK_MODE_TOP_IF) {
         other = workspace()->findClient(Predicate::WindowMatch, above);
         if (other && other->frameGeometry().intersects(frameGeometry()))
             workspace()->raiseClientRequest(this, src, timestamp);
         return;
     }
     else if (detail == XCB_STACK_MODE_BOTTOM_IF) {
         other = workspace()->findClient(Predicate::WindowMatch, above);
         if (other && other->frameGeometry().intersects(frameGeometry()))
             workspace()->lowerClientRequest(this, src, timestamp);
         return;
     }
 
     if (!other)
         other = workspace()->findClient(Predicate::WindowMatch, above);
 
     if (other && detail == XCB_STACK_MODE_ABOVE) {
         auto it = workspace()->stackingOrder().constEnd(),
                                     begin = workspace()->stackingOrder().constBegin();
         while (--it != begin) {
 
             if (*it == other) { // the other one is top on stack
                 it = begin; // invalidate
                 src = NET::FromTool; // force
                 break;
             }
             X11Client *c = qobject_cast<X11Client *>(*it);
 
             if (!c || !(  (*it)->isNormalWindow() && c->isShown(true) &&
                     (*it)->isOnCurrentDesktop() && (*it)->isOnCurrentActivity() && (*it)->isOnScreen(screen()) ))
                 continue; // irrelevant clients
 
             if (*(it - 1) == other)
                 break; // "it" is the one above the target one, stack below "it"
         }
 
         if (it != begin && (*(it - 1) == other))
             other = qobject_cast<X11Client *>(*it);
         else
             other = nullptr;
     }
 
     if (other)
         workspace()->restack(this, other);
     else if (detail == XCB_STACK_MODE_BELOW)
         workspace()->lowerClientRequest(this, src, timestamp);
     else if (detail == XCB_STACK_MODE_ABOVE)
         workspace()->raiseClientRequest(this, src, timestamp);
 
     if (send_event)
         sendSyntheticConfigureNotify();
 }
 
 bool X11Client::belongsToDesktop() const
 {
     foreach (const X11Client *c, group()->members()) {
         if (c->isDesktop())
             return true;
     }
     return false;
 }
 
 } // namespace
diff --git a/plugins/platforms/drm/egl_stream_backend.h b/plugins/platforms/drm/egl_stream_backend.h
index 9a21b17c4..3c1ec67ba 100644
--- a/plugins/platforms/drm/egl_stream_backend.h
+++ b/plugins/platforms/drm/egl_stream_backend.h
@@ -1,116 +1,115 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 NVIDIA Inc.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_EGL_STREAM_BACKEND_H
 #define KWIN_EGL_STREAM_BACKEND_H
 #include "abstract_egl_backend.h"
 #include <KWayland/Server/surface_interface.h>
 #include <KWayland/Server/eglstream_controller_interface.h>
 #include <wayland-server-core.h>
 
 namespace KWin
 {
 
 class DrmBackend;
 class DrmOutput;
 class DrmBuffer;
-class XdgShellClient;
 
 /**
  * @brief OpenGL Backend using Egl with an EGLDevice.
  */
 class EglStreamBackend : public AbstractEglBackend
 {
     Q_OBJECT
 public:
     EglStreamBackend(DrmBackend *b);
     ~EglStreamBackend() override;
     void screenGeometryChanged(const QSize &size) override;
     SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) override;
     QRegion prepareRenderingFrame() override;
     void endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion) override;
     void endRenderingFrameForScreen(int screenId, const QRegion &damage, const QRegion &damagedRegion) override;
     bool usesOverlayWindow() const override;
     bool perScreenRendering() const override;
     QRegion prepareRenderingForScreen(int screenId) override;
     void init() override;
 
 protected:
     void present() override;
     void cleanupSurfaces() override;
 
 private:
     bool initializeEgl();
     bool initBufferConfigs();
     bool initRenderingContext();
     struct StreamTexture 
     {
         EGLStreamKHR stream;
         GLuint texture;
     };
     StreamTexture *lookupStreamTexture(KWayland::Server::SurfaceInterface *surface);
     void attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
                               void *eglStream,
                               wl_array *attribs);
     struct Output 
     {
         DrmOutput *output = nullptr;
         DrmBuffer *buffer = nullptr;
         EGLSurface eglSurface = EGL_NO_SURFACE;
         EGLStreamKHR eglStream = EGL_NO_STREAM_KHR;
     };
     bool resetOutput(Output &output, DrmOutput *drmOutput);
     bool makeContextCurrent(const Output &output);
     void presentOnOutput(Output &output);
     void cleanupOutput(const Output &output);
     void createOutput(DrmOutput *output);
 
     DrmBackend *m_backend;
     QVector<Output> m_outputs;
     KWayland::Server::EglStreamControllerInterface *m_eglStreamControllerInterface;
     QHash<KWayland::Server::SurfaceInterface *, StreamTexture> m_streamTextures;
 
     friend class EglStreamTexture;
 };
 
 /**
  * @brief External texture bound to an EGLStreamKHR.
  */
 class EglStreamTexture : public AbstractEglTexture
 {
 public:
     ~EglStreamTexture() override;
     bool loadTexture(WindowPixmap *pixmap) override;
     void updateTexture(WindowPixmap *pixmap) override;
 
 private:
     EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend);
     bool acquireStreamFrame(EGLStreamKHR stream);
     void createFbo();
     void copyExternalTexture(GLuint tex);
     bool attachBuffer(KWayland::Server::BufferInterface *buffer);
     EglStreamBackend *m_backend;
     GLuint m_fbo, m_rbo;
     GLenum m_format;
     friend class EglStreamBackend;
 };
 
 } // namespace
 
 #endif
diff --git a/pointer_input.cpp b/pointer_input.cpp
index 386a0238e..3650f6cb1 100644
--- a/pointer_input.cpp
+++ b/pointer_input.cpp
@@ -1,1427 +1,1426 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "pointer_input.h"
 #include "platform.h"
 #include "x11client.h"
 #include "effects.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "osd.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "wayland_cursor_theme.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "decorations/decoratedclient.h"
 #include "screens.h"
 // KDecoration
 #include <KDecoration2/Decoration>
 // KWayland
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/datadevice_interface.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/pointerconstraints_interface.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/surface_interface.h>
 // screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <KLocalizedString>
 
 #include <QHoverEvent>
 #include <QWindow>
 #include <QPainter>
 // Wayland
 #include <wayland-cursor.h>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QHash<uint32_t, Qt::MouseButton> s_buttonToQtMouseButton = {
     { BTN_LEFT , Qt::LeftButton },
     { BTN_MIDDLE , Qt::MiddleButton },
     { BTN_RIGHT , Qt::RightButton },
     // in QtWayland mapped like that
     { BTN_SIDE , Qt::ExtraButton1 },
     // in QtWayland mapped like that
     { BTN_EXTRA , Qt::ExtraButton2 },
     { BTN_BACK , Qt::BackButton },
     { BTN_FORWARD , Qt::ForwardButton },
     { BTN_TASK , Qt::TaskButton },
     // mapped like that in QtWayland
     { 0x118 , Qt::ExtraButton6 },
     { 0x119 , Qt::ExtraButton7 },
     { 0x11a , Qt::ExtraButton8 },
     { 0x11b , Qt::ExtraButton9 },
     { 0x11c , Qt::ExtraButton10 },
     { 0x11d , Qt::ExtraButton11 },
     { 0x11e , Qt::ExtraButton12 },
     { 0x11f , Qt::ExtraButton13 },
 };
 
 uint32_t qtMouseButtonToButton(Qt::MouseButton button)
 {
     return s_buttonToQtMouseButton.key(button);
 }
 
 static Qt::MouseButton buttonToQtMouseButton(uint32_t button)
 {
     // all other values get mapped to ExtraButton24
     // this is actually incorrect but doesn't matter in our usage
     // KWin internally doesn't use these high extra buttons anyway
     // it's only needed for recognizing whether buttons are pressed
     // if multiple buttons are mapped to the value the evaluation whether
     // buttons are pressed is correct and that's all we care about.
     return s_buttonToQtMouseButton.value(button, Qt::ExtraButton24);
 }
 
 static bool screenContainsPos(const QPointF &pos)
 {
     for (int i = 0; i < screens()->count(); ++i) {
         if (screens()->geometry(i).contains(pos.toPoint())) {
             return true;
         }
     }
     return false;
 }
 
 static QPointF confineToBoundingBox(const QPointF &pos, const QRectF &boundingBox)
 {
     return QPointF(
         qBound(boundingBox.left(), pos.x(), boundingBox.right() - 1.0),
         qBound(boundingBox.top(), pos.y(), boundingBox.bottom() - 1.0)
     );
 }
 
 PointerInputRedirection::PointerInputRedirection(InputRedirection* parent)
     : InputDeviceHandler(parent)
     , m_cursor(nullptr)
     , m_supportsWarping(Application::usesLibinput())
 {
 }
 
 PointerInputRedirection::~PointerInputRedirection() = default;
 
 void PointerInputRedirection::init()
 {
     Q_ASSERT(!inited());
     m_cursor = new CursorImage(this);
     setInited(true);
     InputDeviceHandler::init();
 
     connect(m_cursor, &CursorImage::changed, kwinApp()->platform(), &Platform::cursorChanged);
     emit m_cursor->changed();
 
     connect(screens(), &Screens::changed, this, &PointerInputRedirection::updateAfterScreenChange);
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this,
             [this] {
                 waylandServer()->seat()->cancelPointerPinchGesture();
                 waylandServer()->seat()->cancelPointerSwipeGesture();
                 update();
             }
         );
     }
     connect(workspace(), &QObject::destroyed, this, [this] { setInited(false); });
     connect(waylandServer(), &QObject::destroyed, this, [this] { setInited(false); });
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
         [this] {
             // need to force a focused pointer change
             waylandServer()->seat()->setFocusedPointerSurface(nullptr);
             setFocus(nullptr);
             update();
         }
     );
     // connect the move resize of all window
     auto setupMoveResizeConnection = [this] (AbstractClient *c) {
         connect(c, &AbstractClient::clientStartUserMovedResized, this, &PointerInputRedirection::updateOnStartMoveResize);
         connect(c, &AbstractClient::clientFinishUserMovedResized, this, &PointerInputRedirection::update);
     };
     const auto clients = workspace()->allClientList();
     std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
     connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
     connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
 
     // warp the cursor to center of screen
     warp(screens()->geometry().center());
     updateAfterScreenChange();
 }
 
 void PointerInputRedirection::updateOnStartMoveResize()
 {
     breakPointerConstraints(focus() ? focus()->surface() : nullptr);
     disconnectPointerConstraintsConnection();
     setFocus(nullptr);
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 }
 
 void PointerInputRedirection::updateToReset()
 {
     if (internalWindow()) {
         disconnect(m_internalWindowConnection);
         m_internalWindowConnection = QMetaObject::Connection();
         QEvent event(QEvent::Leave);
         QCoreApplication::sendEvent(internalWindow().data(), &event);
         setInternalWindow(nullptr);
     }
     if (decoration()) {
         QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::instance()->sendEvent(decoration()->decoration(), &event);
         setDecoration(nullptr);
     }
     if (focus()) {
         if (AbstractClient *c = qobject_cast<AbstractClient*>(focus().data())) {
             c->leaveEvent();
         }
         disconnect(m_focusGeometryConnection);
         m_focusGeometryConnection = QMetaObject::Connection();
         breakPointerConstraints(focus()->surface());
         disconnectPointerConstraintsConnection();
         setFocus(nullptr);
     }
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 }
 
 void PointerInputRedirection::processMotion(const QPointF &pos, uint32_t time, LibInput::Device *device)
 {
     processMotion(pos, QSizeF(), QSizeF(), time, 0, device);
 }
 
 class PositionUpdateBlocker
 {
 public:
     PositionUpdateBlocker(PointerInputRedirection *pointer)
         : m_pointer(pointer)
     {
         s_counter++;
     }
     ~PositionUpdateBlocker() {
         s_counter--;
         if (s_counter == 0) {
             if (!s_scheduledPositions.isEmpty()) {
                 const auto pos = s_scheduledPositions.takeFirst();
                 m_pointer->processMotion(pos.pos, pos.delta, pos.deltaNonAccelerated, pos.time, pos.timeUsec, nullptr);
             }
         }
     }
 
     static bool isPositionBlocked() {
         return s_counter > 0;
     }
 
     static void schedulePosition(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec) {
         s_scheduledPositions.append({pos, delta, deltaNonAccelerated, time, timeUsec});
     }
 
 private:
     static int s_counter;
     struct ScheduledPosition {
         QPointF pos;
         QSizeF delta;
         QSizeF deltaNonAccelerated;
         quint32 time;
         quint64 timeUsec;
     };
     static QVector<ScheduledPosition> s_scheduledPositions;
 
     PointerInputRedirection *m_pointer;
 };
 
 int PositionUpdateBlocker::s_counter = 0;
 QVector<PositionUpdateBlocker::ScheduledPosition> PositionUpdateBlocker::s_scheduledPositions;
 
 void PointerInputRedirection::processMotion(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec, LibInput::Device *device)
 {
     if (!inited()) {
         return;
     }
     if (PositionUpdateBlocker::isPositionBlocked()) {
         PositionUpdateBlocker::schedulePosition(pos, delta, deltaNonAccelerated, time, timeUsec);
         return;
     }
 
     PositionUpdateBlocker blocker(this);
     updatePosition(pos);
     MouseEvent event(QEvent::MouseMove, m_pos, Qt::NoButton, m_qtButtons,
                      input()->keyboardModifiers(), time,
                      delta, deltaNonAccelerated, timeUsec, device);
     event.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
 
     update();
     input()->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
     input()->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, 0));
 }
 
 void PointerInputRedirection::processButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time, LibInput::Device *device)
 {
     QEvent::Type type;
     switch (state) {
     case InputRedirection::PointerButtonReleased:
         type = QEvent::MouseButtonRelease;
         break;
     case InputRedirection::PointerButtonPressed:
         type = QEvent::MouseButtonPress;
         update();
         break;
     default:
         Q_UNREACHABLE();
         return;
     }
 
     updateButton(button, state);
 
     MouseEvent event(type, m_pos, buttonToQtMouseButton(button), m_qtButtons,
                      input()->keyboardModifiers(), time, QSizeF(), QSizeF(), 0, device);
     event.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
     event.setNativeButton(button);
 
     input()->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
 
     if (!inited()) {
         return;
     }
 
     input()->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, button));
 
     if (state == InputRedirection::PointerButtonReleased) {
         update();
     }
 }
 
 void PointerInputRedirection::processAxis(InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta,
     InputRedirection::PointerAxisSource source, uint32_t time, LibInput::Device *device)
 {
     update();
 
     emit input()->pointerAxisChanged(axis, delta);
 
     WheelEvent wheelEvent(m_pos, delta, discreteDelta,
                            (axis == InputRedirection::PointerAxisHorizontal) ? Qt::Horizontal : Qt::Vertical,
                            m_qtButtons, input()->keyboardModifiers(), source, time, device);
     wheelEvent.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
 
     input()->processSpies(std::bind(&InputEventSpy::wheelEvent, std::placeholders::_1, &wheelEvent));
 
     if (!inited()) {
         return;
     }
     input()->processFilters(std::bind(&InputEventFilter::wheelEvent, std::placeholders::_1, &wheelEvent));
 }
 
 void PointerInputRedirection::processSwipeGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
 }
 
 void PointerInputRedirection::processSwipeGestureUpdate(const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureUpdate, std::placeholders::_1, delta, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureUpdate, std::placeholders::_1, delta, time));
 }
 
 void PointerInputRedirection::processSwipeGestureEnd(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureEnd, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureEnd, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processSwipeGestureCancelled(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureCancelled, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureCancelled, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processPinchGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
 }
 
 void PointerInputRedirection::processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
 }
 
 void PointerInputRedirection::processPinchGestureEnd(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureEnd, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureEnd, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processPinchGestureCancelled(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureCancelled, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureCancelled, std::placeholders::_1, time));
 }
 
 bool PointerInputRedirection::areButtonsPressed() const
 {
     for (auto state : m_buttons) {
         if (state == InputRedirection::PointerButtonPressed) {
             return true;
         }
     }
     return false;
 }
 
 bool PointerInputRedirection::focusUpdatesBlocked()
 {
     if (!inited()) {
         return true;
     }
     if (waylandServer()->seat()->isDragPointer()) {
         // ignore during drag and drop
         return true;
     }
     if (waylandServer()->seat()->isTouchSequence()) {
         // ignore during touch operations
         return true;
     }
     if (input()->isSelectingWindow()) {
         return true;
     }
     if (areButtonsPressed()) {
         return true;
     }
     return false;
 }
 
 void PointerInputRedirection::cleanupInternalWindow(QWindow *old, QWindow *now)
 {
     disconnect(m_internalWindowConnection);
     m_internalWindowConnection = QMetaObject::Connection();
 
     if (old) {
         // leave internal window
         QEvent leaveEvent(QEvent::Leave);
         QCoreApplication::sendEvent(old, &leaveEvent);
     }
 
     if (now) {
         m_internalWindowConnection = connect(internalWindow().data(), &QWindow::visibleChanged, this,
             [this] (bool visible) {
                 if (!visible) {
                     update();
                 }
             }
         );
     }
 }
 
 void PointerInputRedirection::cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now)
 {
     disconnect(m_decorationGeometryConnection);
     m_decorationGeometryConnection = QMetaObject::Connection();
     workspace()->updateFocusMousePosition(position().toPoint());
 
     if (old) {
         // send leave event to old decoration
         QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::instance()->sendEvent(old->decoration(), &event);
     }
     if (!now) {
         // left decoration
         return;
     }
 
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 
     auto pos = m_pos - now->client()->pos();
     QHoverEvent event(QEvent::HoverEnter, pos, pos);
     QCoreApplication::instance()->sendEvent(now->decoration(), &event);
     now->client()->processDecorationMove(pos.toPoint(), m_pos.toPoint());
 
     m_decorationGeometryConnection = connect(decoration()->client(), &AbstractClient::frameGeometryChanged, this,
         [this] {
             // ensure maximize button gets the leave event when maximizing/restore a window, see BUG 385140
             const auto oldDeco = decoration();
             update();
             if (oldDeco &&
                     oldDeco == decoration() &&
                     !decoration()->client()->isMove() &&
                     !decoration()->client()->isResize() &&
                     !areButtonsPressed()) {
                 // position of window did not change, we need to send HoverMotion manually
                 const QPointF p = m_pos - decoration()->client()->pos();
                 QHoverEvent event(QEvent::HoverMove, p, p);
                 QCoreApplication::instance()->sendEvent(decoration()->decoration(), &event);
             }
         }, Qt::QueuedConnection);
 }
 
 static bool s_cursorUpdateBlocking = false;
 
 void PointerInputRedirection::focusUpdate(Toplevel *focusOld, Toplevel *focusNow)
 {
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusOld)) {
         ac->leaveEvent();
         breakPointerConstraints(ac->surface());
         disconnectPointerConstraintsConnection();
     }
     disconnect(m_focusGeometryConnection);
     m_focusGeometryConnection = QMetaObject::Connection();
 
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusNow)) {
         ac->enterEvent(m_pos.toPoint());
         workspace()->updateFocusMousePosition(m_pos.toPoint());
     }
 
     if (internalWindow()) {
         // enter internal window
         const auto pos = at()->pos();
         QEnterEvent enterEvent(pos, pos, m_pos);
         QCoreApplication::sendEvent(internalWindow().data(), &enterEvent);
     }
 
     auto seat = waylandServer()->seat();
     if (!focusNow || !focusNow->surface() || decoration()) {
         // Clean up focused pointer surface if there's no client to take focus,
         // or the pointer is on a client without surface or on a decoration.
         warpXcbOnSurfaceLeft(nullptr);
         seat->setFocusedPointerSurface(nullptr);
         return;
     }
 
     // TODO: add convenient API to update global pos together with updating focused surface
     warpXcbOnSurfaceLeft(focusNow->surface());
 
     // TODO: why? in order to reset the cursor icon?
     s_cursorUpdateBlocking = true;
     seat->setFocusedPointerSurface(nullptr);
     s_cursorUpdateBlocking = false;
 
     seat->setPointerPos(m_pos.toPoint());
     seat->setFocusedPointerSurface(focusNow->surface(), focusNow->inputTransformation());
 
     m_focusGeometryConnection = connect(focusNow, &Toplevel::frameGeometryChanged, this,
         [this] {
             // TODO: why no assert possible?
             if (!focus()) {
                 return;
             }
             // TODO: can we check on the client instead?
             if (workspace()->moveResizeClient()) {
                 // don't update while moving
                 return;
             }
             auto seat = waylandServer()->seat();
             if (focus()->surface() != seat->focusedPointerSurface()) {
                 return;
             }
             seat->setFocusedPointerSurfaceTransformation(focus()->inputTransformation());
         }
     );
 
     m_constraintsConnection = connect(focusNow->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged,
                                       this, &PointerInputRedirection::updatePointerConstraints);
     m_constraintsActivatedConnection = connect(workspace(), &Workspace::clientActivated,
                                                this, &PointerInputRedirection::updatePointerConstraints);
     updatePointerConstraints();
 }
 
 void PointerInputRedirection::breakPointerConstraints(KWayland::Server::SurfaceInterface *surface)
 {
     // cancel pointer constraints
     if (surface) {
         auto c = surface->confinedPointer();
         if (c && c->isConfined()) {
             c->setConfined(false);
         }
         auto l = surface->lockedPointer();
         if (l && l->isLocked()) {
             l->setLocked(false);
         }
     }
     disconnectConfinedPointerRegionConnection();
     m_confined = false;
     m_locked = false;
 }
 
 void PointerInputRedirection::disconnectConfinedPointerRegionConnection()
 {
     disconnect(m_confinedPointerRegionConnection);
     m_confinedPointerRegionConnection = QMetaObject::Connection();
 }
 
 void PointerInputRedirection::disconnectLockedPointerAboutToBeUnboundConnection()
 {
     disconnect(m_lockedPointerAboutToBeUnboundConnection);
     m_lockedPointerAboutToBeUnboundConnection = QMetaObject::Connection();
 }
 
 void PointerInputRedirection::disconnectPointerConstraintsConnection()
 {
     disconnect(m_constraintsConnection);
     m_constraintsConnection = QMetaObject::Connection();
 
     disconnect(m_constraintsActivatedConnection);
     m_constraintsActivatedConnection = QMetaObject::Connection();
 }
 
 template <typename T>
 static QRegion getConstraintRegion(Toplevel *t, T *constraint)
 {
     const QRegion windowShape = t->inputShape();
     const QRegion windowRegion = windowShape.isEmpty() ? QRegion(0, 0, t->clientSize().width(), t->clientSize().height()) : windowShape;
     const QRegion intersected = constraint->region().isEmpty() ? windowRegion : windowRegion.intersected(constraint->region());
     return intersected.translated(t->pos() + t->clientPos());
 }
 
 void PointerInputRedirection::setEnableConstraints(bool set)
 {
     if (m_enableConstraints == set) {
         return;
     }
     m_enableConstraints = set;
     updatePointerConstraints();
 }
 
 void PointerInputRedirection::updatePointerConstraints()
 {
     if (focus().isNull()) {
         return;
     }
     const auto s = focus()->surface();
     if (!s) {
         return;
     }
     if (s != waylandServer()->seat()->focusedPointerSurface()) {
         return;
     }
     if (!supportsWarping()) {
         return;
     }
     const bool canConstrain = m_enableConstraints && focus() == workspace()->activeClient();
     const auto cf = s->confinedPointer();
     if (cf) {
         if (cf->isConfined()) {
             if (!canConstrain) {
                 cf->setConfined(false);
                 m_confined = false;
                 disconnectConfinedPointerRegionConnection();
             }
             return;
         }
         const QRegion r = getConstraintRegion(focus().data(), cf.data());
         if (canConstrain && r.contains(m_pos.toPoint())) {
             cf->setConfined(true);
             m_confined = true;
             m_confinedPointerRegionConnection = connect(cf.data(), &KWayland::Server::ConfinedPointerInterface::regionChanged, this,
                 [this] {
                     if (!focus()) {
                         return;
                     }
                     const auto s = focus()->surface();
                     if (!s) {
                         return;
                     }
                     const auto cf = s->confinedPointer();
                     if (!getConstraintRegion(focus().data(), cf.data()).contains(m_pos.toPoint())) {
                         // pointer no longer in confined region, break the confinement
                         cf->setConfined(false);
                         m_confined = false;
                     } else {
                         if (!cf->isConfined()) {
                             cf->setConfined(true);
                             m_confined = true;
                         }
                     }
                 }
             );
             return;
         }
     } else {
         m_confined = false;
         disconnectConfinedPointerRegionConnection();
     }
     const auto lock = s->lockedPointer();
     if (lock) {
         if (lock->isLocked()) {
             if (!canConstrain) {
                 const auto hint = lock->cursorPositionHint();
                 lock->setLocked(false);
                 m_locked = false;
                 disconnectLockedPointerAboutToBeUnboundConnection();
                 if (! (hint.x() < 0 || hint.y() < 0) && focus()) {
                     processMotion(focus()->pos() - focus()->clientContentPos() + hint, waylandServer()->seat()->timestamp());
                 }
             }
             return;
         }
         const QRegion r = getConstraintRegion(focus().data(), lock.data());
         if (canConstrain && r.contains(m_pos.toPoint())) {
             lock->setLocked(true);
             m_locked = true;
 
             // The client might cancel pointer locking from its side by unbinding the LockedPointerInterface.
             // In this case the cached cursor position hint must be fetched before the resource goes away
             m_lockedPointerAboutToBeUnboundConnection = connect(lock.data(), &KWayland::Server::LockedPointerInterface::aboutToBeUnbound, this,
                 [this, lock]() {
                     const auto hint = lock->cursorPositionHint();
                     if (hint.x() < 0 || hint.y() < 0 || !focus()) {
                         return;
                     }
                     auto globalHint = focus()->pos() - focus()->clientContentPos() + hint;
 
                     // When the resource finally goes away, reposition the cursor according to the hint
                     connect(lock.data(), &KWayland::Server::LockedPointerInterface::unbound, this,
                         [this, globalHint]() {
                             processMotion(globalHint, waylandServer()->seat()->timestamp());
                     });
                 }
             );
             // TODO: connect to region change - is it needed at all? If the pointer is locked it's always in the region
         }
     } else {
         m_locked = false;
         disconnectLockedPointerAboutToBeUnboundConnection();
     }
 }
 
 void PointerInputRedirection::warpXcbOnSurfaceLeft(KWayland::Server::SurfaceInterface *newSurface)
 {
     auto xc = waylandServer()->xWaylandConnection();
     if (!xc) {
         // No XWayland, no point in warping the x cursor
         return;
     }
     const auto c = kwinApp()->x11Connection();
     if (!c) {
         return;
     }
     static bool s_hasXWayland119 = xcb_get_setup(c)->release_number >= 11900000;
     if (s_hasXWayland119) {
         return;
     }
     if (newSurface && newSurface->client() == xc) {
         // new window is an X window
         return;
     }
     auto s = waylandServer()->seat()->focusedPointerSurface();
     if (!s || s->client() != xc) {
         // pointer was not on an X window
         return;
     }
     // warp pointer to 0/0 to trigger leave events on previously focused X window
     xcb_warp_pointer(c, XCB_WINDOW_NONE, kwinApp()->x11RootWindow(), 0, 0, 0, 0, 0, 0),
     xcb_flush(c);
 }
 
 QPointF PointerInputRedirection::applyPointerConfinement(const QPointF &pos) const
 {
     if (!focus()) {
         return pos;
     }
     auto s = focus()->surface();
     if (!s) {
         return pos;
     }
     auto cf = s->confinedPointer();
     if (!cf) {
         return pos;
     }
     if (!cf->isConfined()) {
         return pos;
     }
 
     const QRegion confinementRegion = getConstraintRegion(focus().data(), cf.data());
     if (confinementRegion.contains(pos.toPoint())) {
         return pos;
     }
     QPointF p = pos;
     // allow either x or y to pass
     p = QPointF(m_pos.x(), pos.y());
     if (confinementRegion.contains(p.toPoint())) {
         return p;
     }
     p = QPointF(pos.x(), m_pos.y());
     if (confinementRegion.contains(p.toPoint())) {
         return p;
     }
 
     return m_pos;
 }
 
 void PointerInputRedirection::updatePosition(const QPointF &pos)
 {
     if (m_locked) {
         // locked pointer should not move
         return;
     }
     // verify that at least one screen contains the pointer position
     QPointF p = pos;
     if (!screenContainsPos(p)) {
         const QRectF unitedScreensGeometry = screens()->geometry();
         p = confineToBoundingBox(p, unitedScreensGeometry);
         if (!screenContainsPos(p)) {
             const QRectF currentScreenGeometry = screens()->geometry(screens()->number(m_pos.toPoint()));
             p = confineToBoundingBox(p, currentScreenGeometry);
         }
     }
     p = applyPointerConfinement(p);
     if (p == m_pos) {
         // didn't change due to confinement
         return;
     }
     // verify screen confinement
     if (!screenContainsPos(p)) {
         return;
     }
     m_pos = p;
     emit input()->globalPointerChanged(m_pos);
 }
 
 void PointerInputRedirection::updateButton(uint32_t button, InputRedirection::PointerButtonState state)
 {
     m_buttons[button] = state;
 
     // update Qt buttons
     m_qtButtons = Qt::NoButton;
     for (auto it = m_buttons.constBegin(); it != m_buttons.constEnd(); ++it) {
         if (it.value() == InputRedirection::PointerButtonReleased) {
             continue;
         }
         m_qtButtons |= buttonToQtMouseButton(it.key());
     }
 
     emit input()->pointerButtonStateChanged(button, state);
 }
 
 void PointerInputRedirection::warp(const QPointF &pos)
 {
     if (supportsWarping()) {
         kwinApp()->platform()->warpPointer(pos);
         processMotion(pos, waylandServer()->seat()->timestamp());
     }
 }
 
 bool PointerInputRedirection::supportsWarping() const
 {
     if (!inited()) {
         return false;
     }
     if (m_supportsWarping) {
         return true;
     }
     if (kwinApp()->platform()->supportsPointerWarping()) {
         return true;
     }
     return false;
 }
 
 void PointerInputRedirection::updateAfterScreenChange()
 {
     if (!inited()) {
         return;
     }
     if (screenContainsPos(m_pos)) {
         // pointer still on a screen
         return;
     }
     // pointer no longer on a screen, reposition to closes screen
     const QPointF pos = screens()->geometry(screens()->number(m_pos.toPoint())).center();
     // TODO: better way to get timestamps
     processMotion(pos, waylandServer()->seat()->timestamp());
 }
 
 QImage PointerInputRedirection::cursorImage() const
 {
     if (!inited()) {
         return QImage();
     }
     return m_cursor->image();
 }
 
 QPoint PointerInputRedirection::cursorHotSpot() const
 {
     if (!inited()) {
         return QPoint();
     }
     return m_cursor->hotSpot();
 }
 
 void PointerInputRedirection::markCursorAsRendered()
 {
     if (!inited()) {
         return;
     }
     m_cursor->markAsRendered();
 }
 
 QPointF PointerInputRedirection::position() const
 {
     return m_pos.toPoint();
 }
 
 void PointerInputRedirection::setEffectsOverrideCursor(Qt::CursorShape shape)
 {
     if (!inited()) {
         return;
     }
     // current pointer focus window should get a leave event
     update();
     m_cursor->setEffectsOverrideCursor(shape);
 }
 
 void PointerInputRedirection::removeEffectsOverrideCursor()
 {
     if (!inited()) {
         return;
     }
     // cursor position might have changed while there was an effect in place
     update();
     m_cursor->removeEffectsOverrideCursor();
 }
 
 void PointerInputRedirection::setWindowSelectionCursor(const QByteArray &shape)
 {
     if (!inited()) {
         return;
     }
     // send leave to current pointer focus window
     updateToReset();
     m_cursor->setWindowSelectionCursor(shape);
 }
 
 void PointerInputRedirection::removeWindowSelectionCursor()
 {
     if (!inited()) {
         return;
     }
     update();
     m_cursor->removeWindowSelectionCursor();
 }
 
 CursorImage::CursorImage(PointerInputRedirection *parent)
     : QObject(parent)
     , m_pointer(parent)
 {
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::focusedPointerChanged, this, &CursorImage::update);
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragStarted, this, &CursorImage::updateDrag);
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
         [this] {
             disconnect(m_drag.connection);
             reevaluteSource();
         }
     );
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this, &CursorImage::reevaluteSource);
     }
     connect(m_pointer, &PointerInputRedirection::decorationChanged, this, &CursorImage::updateDecoration);
     // connect the move resize of all window
     auto setupMoveResizeConnection = [this] (AbstractClient *c) {
         connect(c, &AbstractClient::moveResizedChanged, this, &CursorImage::updateMoveResize);
         connect(c, &AbstractClient::moveResizeCursorChanged, this, &CursorImage::updateMoveResize);
     };
     const auto clients = workspace()->allClientList();
     std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
     connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
     connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
     loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
     if (m_cursorTheme) {
         connect(m_cursorTheme, &WaylandCursorTheme::themeChanged, this,
             [this] {
                 m_cursors.clear();
                 m_cursorsByName.clear();
                 loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
                 updateDecorationCursor();
                 updateMoveResize();
                 // TODO: update effects
             }
         );
     }
     m_surfaceRenderedTimer.start();
 }
 
 CursorImage::~CursorImage() = default;
 
 void CursorImage::markAsRendered()
 {
     if (m_currentSource == CursorSource::DragAndDrop) {
         // always sending a frame rendered to the drag icon surface to not freeze QtWayland (see https://bugreports.qt.io/browse/QTBUG-51599 )
         if (auto ddi = waylandServer()->seat()->dragSource()) {
             if (auto s = ddi->icon()) {
                 s->frameRendered(m_surfaceRenderedTimer.elapsed());
             }
         }
         auto p = waylandServer()->seat()->dragPointer();
         if (!p) {
             return;
         }
         auto c = p->cursor();
         if (!c) {
             return;
         }
         auto cursorSurface = c->surface();
         if (cursorSurface.isNull()) {
             return;
         }
         cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
         return;
     }
     if (m_currentSource != CursorSource::LockScreen && m_currentSource != CursorSource::PointerSurface) {
         return;
     }
     auto p = waylandServer()->seat()->focusedPointer();
     if (!p) {
         return;
     }
     auto c = p->cursor();
     if (!c) {
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         return;
     }
     cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
 }
 
 void CursorImage::update()
 {
     if (s_cursorUpdateBlocking) {
         return;
     }
     using namespace KWayland::Server;
     disconnect(m_serverCursor.connection);
     auto p = waylandServer()->seat()->focusedPointer();
     if (p) {
         m_serverCursor.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateServerCursor);
     } else {
         m_serverCursor.connection = QMetaObject::Connection();
         reevaluteSource();
     }
 }
 
 void CursorImage::updateDecoration()
 {
     disconnect(m_decorationConnection);
     auto deco = m_pointer->decoration();
     AbstractClient *c = deco.isNull() ? nullptr : deco->client();
     if (c) {
         m_decorationConnection = connect(c, &AbstractClient::moveResizeCursorChanged, this, &CursorImage::updateDecorationCursor);
     } else {
         m_decorationConnection = QMetaObject::Connection();
     }
     updateDecorationCursor();
 }
 
 void CursorImage::updateDecorationCursor()
 {
     m_decorationCursor.image = QImage();
     m_decorationCursor.hotSpot = QPoint();
 
     auto deco = m_pointer->decoration();
     if (AbstractClient *c = deco.isNull() ? nullptr : deco->client()) {
         loadThemeCursor(c->cursor(), &m_decorationCursor);
         if (m_currentSource == CursorSource::Decoration) {
             emit changed();
         }
     }
     reevaluteSource();
 }
 
 void CursorImage::updateMoveResize()
 {
     m_moveResizeCursor.image = QImage();
     m_moveResizeCursor.hotSpot = QPoint();
     if (AbstractClient *c = workspace()->moveResizeClient()) {
         loadThemeCursor(c->cursor(), &m_moveResizeCursor);
         if (m_currentSource == CursorSource::MoveResize) {
             emit changed();
         }
     }
     reevaluteSource();
 }
 
 void CursorImage::updateServerCursor()
 {
     m_serverCursor.image = QImage();
     m_serverCursor.hotSpot = QPoint();
     reevaluteSource();
     const bool needsEmit = m_currentSource == CursorSource::LockScreen || m_currentSource == CursorSource::PointerSurface;
     auto p = waylandServer()->seat()->focusedPointer();
     if (!p) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto c = p->cursor();
     if (!c) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto buffer = cursorSurface.data()->buffer();
     if (!buffer) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     m_serverCursor.hotSpot = c->hotspot();
     m_serverCursor.image = buffer->data().copy();
     m_serverCursor.image.setDevicePixelRatio(cursorSurface->scale());
     if (needsEmit) {
         emit changed();
     }
 }
 
 void CursorImage::loadTheme()
 {
     if (m_cursorTheme) {
         return;
     }
     // check whether we can create it
     if (waylandServer()->internalShmPool()) {
         m_cursorTheme = new WaylandCursorTheme(waylandServer()->internalShmPool(), this);
         connect(waylandServer(), &WaylandServer::terminatingInternalClientConnection, this,
             [this] {
                 delete m_cursorTheme;
                 m_cursorTheme = nullptr;
             }
         );
     }
 }
 
 void CursorImage::setEffectsOverrideCursor(Qt::CursorShape shape)
 {
     loadThemeCursor(shape, &m_effectsCursor);
     if (m_currentSource == CursorSource::EffectsOverride) {
         emit changed();
     }
     reevaluteSource();
 }
 
 void CursorImage::removeEffectsOverrideCursor()
 {
     reevaluteSource();
 }
 
 void CursorImage::setWindowSelectionCursor(const QByteArray &shape)
 {
     if (shape.isEmpty()) {
         loadThemeCursor(Qt::CrossCursor, &m_windowSelectionCursor);
     } else {
         loadThemeCursor(shape, &m_windowSelectionCursor);
     }
     if (m_currentSource == CursorSource::WindowSelector) {
         emit changed();
     }
     reevaluteSource();
 }
 
 void CursorImage::removeWindowSelectionCursor()
 {
     reevaluteSource();
 }
 
 void CursorImage::updateDrag()
 {
     using namespace KWayland::Server;
     disconnect(m_drag.connection);
     m_drag.cursor.image = QImage();
     m_drag.cursor.hotSpot = QPoint();
     reevaluteSource();
     if (auto p = waylandServer()->seat()->dragPointer()) {
         m_drag.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateDragCursor);
     } else {
         m_drag.connection = QMetaObject::Connection();
     }
     updateDragCursor();
 }
 
 void CursorImage::updateDragCursor()
 {
     m_drag.cursor.image = QImage();
     m_drag.cursor.hotSpot = QPoint();
     const bool needsEmit = m_currentSource == CursorSource::DragAndDrop;
     QImage additionalIcon;
     if (auto ddi = waylandServer()->seat()->dragSource()) {
         if (auto dragIcon = ddi->icon()) {
             if (auto buffer = dragIcon->buffer()) {
                 additionalIcon = buffer->data().copy();
                 additionalIcon.setOffset(dragIcon->offset());
             }
         }
     }
     auto p = waylandServer()->seat()->dragPointer();
     if (!p) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto c = p->cursor();
     if (!c) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto buffer = cursorSurface.data()->buffer();
     if (!buffer) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     m_drag.cursor.hotSpot = c->hotspot();
 
     if (additionalIcon.isNull()) {
         m_drag.cursor.image = buffer->data().copy();
     } else {
         QRect cursorRect = buffer->data().rect();
         QRect iconRect = additionalIcon.rect();
 
         if (-m_drag.cursor.hotSpot.x() < additionalIcon.offset().x()) {
             iconRect.moveLeft(m_drag.cursor.hotSpot.x() - additionalIcon.offset().x());
         } else {
             cursorRect.moveLeft(-additionalIcon.offset().x() - m_drag.cursor.hotSpot.x());
         }
         if (-m_drag.cursor.hotSpot.y() < additionalIcon.offset().y()) {
             iconRect.moveTop(m_drag.cursor.hotSpot.y() - additionalIcon.offset().y());
         } else {
             cursorRect.moveTop(-additionalIcon.offset().y() - m_drag.cursor.hotSpot.y());
         }
 
         m_drag.cursor.image = QImage(cursorRect.united(iconRect).size(), QImage::Format_ARGB32_Premultiplied);
         m_drag.cursor.image.fill(Qt::transparent);
         QPainter p(&m_drag.cursor.image);
         p.drawImage(iconRect, additionalIcon);
         p.drawImage(cursorRect, buffer->data());
         p.end();
     }
 
     if (needsEmit) {
         emit changed();
     }
     // TODO: add the cursor image
 }
 
 void CursorImage::loadThemeCursor(CursorShape shape, Image *image)
 {
     loadThemeCursor(shape, m_cursors, image);
 }
 
 void CursorImage::loadThemeCursor(const QByteArray &shape, Image *image)
 {
     loadThemeCursor(shape, m_cursorsByName, image);
 }
 
 template <typename T>
 void CursorImage::loadThemeCursor(const T &shape, QHash<T, Image> &cursors, Image *image)
 {
     loadTheme();
     if (!m_cursorTheme) {
         return;
     }
     auto it = cursors.constFind(shape);
     if (it == cursors.constEnd()) {
         image->image = QImage();
         image->hotSpot = QPoint();
         wl_cursor_image *cursor = m_cursorTheme->get(shape);
         if (!cursor) {
             return;
         }
         wl_buffer *b = wl_cursor_image_get_buffer(cursor);
         if (!b) {
             return;
         }
         waylandServer()->internalClientConection()->flush();
         waylandServer()->dispatch();
         auto buffer = KWayland::Server::BufferInterface::get(waylandServer()->internalConnection()->getResource(KWayland::Client::Buffer::getId(b)));
         if (!buffer) {
             return;
         }
         auto scale = screens()->maxScale();
         int hotSpotX = qRound(cursor->hotspot_x / scale);
         int hotSpotY = qRound(cursor->hotspot_y / scale);
         QImage img = buffer->data().copy();
         img.setDevicePixelRatio(scale);
         it = decltype(it)(cursors.insert(shape, {img, QPoint(hotSpotX, hotSpotY)}));
     }
     image->hotSpot = it.value().hotSpot;
     image->image = it.value().image;
 }
 
 void CursorImage::reevaluteSource()
 {
     if (waylandServer()->seat()->isDragPointer()) {
         // TODO: touch drag?
         setSource(CursorSource::DragAndDrop);
         return;
     }
     if (waylandServer()->isScreenLocked()) {
         setSource(CursorSource::LockScreen);
         return;
     }
     if (input()->isSelectingWindow()) {
         setSource(CursorSource::WindowSelector);
         return;
     }
     if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
         setSource(CursorSource::EffectsOverride);
         return;
     }
     if (workspace() && workspace()->moveResizeClient()) {
         setSource(CursorSource::MoveResize);
         return;
     }
     if (!m_pointer->decoration().isNull()) {
         setSource(CursorSource::Decoration);
         return;
     }
     if (!m_pointer->focus().isNull() && waylandServer()->seat()->focusedPointer()) {
         setSource(CursorSource::PointerSurface);
         return;
     }
     setSource(CursorSource::Fallback);
 }
 
 void CursorImage::setSource(CursorSource source)
 {
     if (m_currentSource == source) {
         return;
     }
     m_currentSource = source;
     emit changed();
 }
 
 QImage CursorImage::image() const
 {
     switch (m_currentSource) {
     case CursorSource::EffectsOverride:
         return m_effectsCursor.image;
     case CursorSource::MoveResize:
         return m_moveResizeCursor.image;
     case CursorSource::LockScreen:
     case CursorSource::PointerSurface:
         // lockscreen also uses server cursor image
         return m_serverCursor.image;
     case CursorSource::Decoration:
         return m_decorationCursor.image;
     case CursorSource::DragAndDrop:
         return m_drag.cursor.image;
     case CursorSource::Fallback:
         return m_fallbackCursor.image;
     case CursorSource::WindowSelector:
         return m_windowSelectionCursor.image;
     default:
         Q_UNREACHABLE();
     }
 }
 
 QPoint CursorImage::hotSpot() const
 {
     switch (m_currentSource) {
     case CursorSource::EffectsOverride:
         return m_effectsCursor.hotSpot;
     case CursorSource::MoveResize:
         return m_moveResizeCursor.hotSpot;
     case CursorSource::LockScreen:
     case CursorSource::PointerSurface:
         // lockscreen also uses server cursor image
         return m_serverCursor.hotSpot;
     case CursorSource::Decoration:
         return m_decorationCursor.hotSpot;
     case CursorSource::DragAndDrop:
         return m_drag.cursor.hotSpot;
     case CursorSource::Fallback:
         return m_fallbackCursor.hotSpot;
     case CursorSource::WindowSelector:
         return m_windowSelectionCursor.hotSpot;
     default:
         Q_UNREACHABLE();
     }
 }
 
 }
diff --git a/popup_input_filter.cpp b/popup_input_filter.cpp
index 93f79da0e..769519c8d 100644
--- a/popup_input_filter.cpp
+++ b/popup_input_filter.cpp
@@ -1,88 +1,88 @@
 /*
  * Copyright 2017  Martin Graesslin <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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "popup_input_filter.h"
+#include "abstract_client.h"
 #include "deleted.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 
 #include <QMouseEvent>
 
 namespace KWin
 {
 
 PopupInputFilter::PopupInputFilter()
     : QObject()
 {
     connect(waylandServer(), &WaylandServer::shellClientAdded, this, &PopupInputFilter::handleClientAdded);
 }
 
 void PopupInputFilter::handleClientAdded(Toplevel *client)
 {
     if (m_popupClients.contains(client)) {
         return;
     }
     if (client->hasPopupGrab()) {
         // TODO: verify that the Toplevel is allowed as a popup
         connect(client, &Toplevel::windowShown, this, &PopupInputFilter::handleClientAdded, Qt::UniqueConnection);
         connect(client, &Toplevel::windowClosed, this, &PopupInputFilter::handleClientRemoved, Qt::UniqueConnection);
         m_popupClients << client;
     }
 }
 
 void PopupInputFilter::handleClientRemoved(Toplevel *client)
 {
     m_popupClients.removeOne(client);
 }
 bool PopupInputFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(nativeButton)
     if (m_popupClients.isEmpty()) {
         return false;
     }
     if (event->type() == QMouseEvent::MouseButtonPress) {
         auto pointerFocus = qobject_cast<AbstractClient*>(input()->findToplevel(event->globalPos()));
         if (!pointerFocus || !AbstractClient::belongToSameApplication(pointerFocus, qobject_cast<AbstractClient*>(m_popupClients.constLast()))) {
             // a press on a window (or no window) not belonging to the popup window
             cancelPopups();
             // filter out this press
             return true;
         }
         if (pointerFocus && pointerFocus->isDecorated()) {
             // test whether it is on the decoration
             const QRect clientRect = QRect(pointerFocus->clientPos(), pointerFocus->clientSize()).translated(pointerFocus->pos());
             if (!clientRect.contains(event->globalPos())) {
                 cancelPopups();
                 return true;
             }
         }
     }
     return false;
 }
 
 void PopupInputFilter::cancelPopups()
 {
     while (!m_popupClients.isEmpty()) {
         auto c = m_popupClients.takeLast();
         c->popupDone();
     }
 }
 
 }
diff --git a/popup_input_filter.h b/popup_input_filter.h
index 8d34e1be2..21ae3b4a6 100644
--- a/popup_input_filter.h
+++ b/popup_input_filter.h
@@ -1,50 +1,49 @@
 /*
  * Copyright 2017  Martin Graesslin <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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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_POPUP_INPUT_FILTER
 #define KWIN_POPUP_INPUT_FILTER
 
 #include "input.h"
 
 #include <QObject>
 #include <QVector>
 
 namespace KWin
 {
 class Toplevel;
-class XdgShellClient;
 
 class PopupInputFilter : public QObject, public InputEventFilter
 {
     Q_OBJECT
 public:
     explicit PopupInputFilter();
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override;
 private:
     void handleClientAdded(Toplevel *client);
     void handleClientRemoved(Toplevel *client);
     void disconnectClient(Toplevel *client);
     void cancelPopups();
 
     QVector<Toplevel*> m_popupClients;
 };
 }
 
 #endif
diff --git a/scripting/scripting_model.cpp b/scripting/scripting_model.cpp
index 682a02575..eb40815ee 100644
--- a/scripting/scripting_model.cpp
+++ b/scripting/scripting_model.cpp
@@ -1,922 +1,921 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "scripting_model.h"
 #include <config-kwin.h>
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "x11client.h"
 #include "screens.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 
 namespace KWin {
 namespace ScriptingClientModel {
 
 static quint32 nextId() {
     static quint32 counter = 0;
     return ++counter;
 }
 
 ClientLevel::ClientLevel(ClientModel *model, AbstractLevel *parent)
     : AbstractLevel(model, parent)
 {
     connect(Workspace::self(), &Workspace::clientAdded, this, &ClientLevel::clientAdded);
     connect(Workspace::self(), &Workspace::clientRemoved, this, &ClientLevel::clientRemoved);
     connect(model, SIGNAL(exclusionsChanged()), SLOT(reInit()));
     if (waylandServer()) {
         connect(waylandServer(), &WaylandServer::shellClientAdded, this, &ClientLevel::clientAdded);
     }
 }
 
 ClientLevel::~ClientLevel()
 {
 }
 
 void ClientLevel::clientAdded(AbstractClient *client)
 {
     setupClientConnections(client);
     checkClient(client);
 }
 
 void ClientLevel::clientRemoved(AbstractClient *client)
 {
     removeClient(client);
 }
 
 void ClientLevel::setupClientConnections(AbstractClient *client)
 {
     auto check = [this, client] {
         checkClient(client);
     };
     connect(client, &AbstractClient::desktopChanged, this, check);
     connect(client, &AbstractClient::screenChanged, this, check);
     connect(client, &AbstractClient::activitiesChanged, this, check);
     connect(client, &AbstractClient::windowHidden, this, check);
     connect(client, &AbstractClient::windowShown, this, check);
 }
 
 void ClientLevel::checkClient(AbstractClient *client)
 {
     const bool shouldInclude = !exclude(client) && shouldAdd(client);
     const bool contains = containsClient(client);
 
     if (shouldInclude && !contains) {
         addClient(client);
     } else if (!shouldInclude && contains) {
         removeClient(client);
     }
 }
 
 bool ClientLevel::exclude(AbstractClient *client) const
 {
     ClientModel::Exclusions exclusions = model()->exclusions();
     if (exclusions == ClientModel::NoExclusion) {
         return false;
     }
     if (exclusions & ClientModel::DesktopWindowsExclusion) {
         if (client->isDesktop()) {
             return true;
         }
     }
     if (exclusions & ClientModel::DockWindowsExclusion) {
         if (client->isDock()) {
             return true;
         }
     }
     if (exclusions & ClientModel::UtilityWindowsExclusion) {
         if (client->isUtility()) {
             return true;
         }
     }
     if (exclusions & ClientModel::SpecialWindowsExclusion) {
         if (client->isSpecialWindow()) {
             return true;
         }
     }
     if (exclusions & ClientModel::SkipTaskbarExclusion) {
         if (client->skipTaskbar()) {
             return true;
         }
     }
     if (exclusions & ClientModel::SkipPagerExclusion) {
         if (client->skipPager()) {
             return true;
         }
     }
     if (exclusions & ClientModel::SwitchSwitcherExclusion) {
         if (client->skipSwitcher()) {
             return true;
         }
     }
     if (exclusions & ClientModel::OtherDesktopsExclusion) {
         if (!client->isOnCurrentDesktop()) {
             return true;
         }
     }
     if (exclusions & ClientModel::OtherActivitiesExclusion) {
         if (!client->isOnCurrentActivity()) {
             return true;
         }
     }
     if (exclusions & ClientModel::MinimizedExclusion) {
         if (client->isMinimized()) {
             return true;
         }
     }
     if (exclusions & ClientModel::NotAcceptingFocusExclusion) {
         if (!client->wantsInput()) {
             return true;
         }
     }
     return false;
 }
 
 bool ClientLevel::shouldAdd(AbstractClient *client) const
 {
     if (restrictions() == ClientModel::NoRestriction) {
         return true;
     }
     if (restrictions() & ClientModel::ActivityRestriction) {
         if (!client->isOnActivity(activity())) {
             return false;
         }
     }
     if (restrictions() & ClientModel::VirtualDesktopRestriction) {
         if (!client->isOnDesktop(virtualDesktop())) {
             return false;
         }
     }
     if (restrictions() & ClientModel::ScreenRestriction) {
         if (client->screen() != int(screen())) {
             return false;
         }
     }
     return true;
 }
 
 void ClientLevel::addClient(AbstractClient *client)
 {
     if (containsClient(client)) {
         return;
     }
     emit beginInsert(m_clients.count(), m_clients.count(), id());
     m_clients.insert(nextId(), client);
     emit endInsert();
 }
 
 void ClientLevel::removeClient(AbstractClient *client)
 {
     int index = 0;
     auto it = m_clients.begin();
     for (; it != m_clients.end(); ++it, ++index) {
         if (it.value() == client) {
             break;
         }
     }
     if (it == m_clients.end()) {
         return;
     }
     emit beginRemove(index, index, id());
     m_clients.erase(it);
     emit endRemove();
 }
 
 void ClientLevel::init()
 {
     const QList<X11Client *> &clients = Workspace::self()->clientList();
     for (auto it = clients.begin(); it != clients.end(); ++it) {
         X11Client *client = *it;
         setupClientConnections(client);
         if (!exclude(client) && shouldAdd(client)) {
             m_clients.insert(nextId(), client);
         }
     }
 }
 
 void ClientLevel::reInit()
 {
     const QList<X11Client *> &clients = Workspace::self()->clientList();
     for (auto it = clients.begin(); it != clients.end(); ++it) {
         checkClient((*it));
     }
     if (waylandServer()) {
         const auto &clients = waylandServer()->clients();
         for (auto *c : clients) {
             checkClient(c);
         }
     }
 }
 
 quint32 ClientLevel::idForRow(int row) const
 {
     if (row >= m_clients.size()) {
         return 0;
     }
     auto it = m_clients.constBegin();
     for (int i=0; i<row; ++i) {
         ++it;
     }
     return it.key();
 }
 
 bool ClientLevel::containsId(quint32 id) const
 {
     return m_clients.contains(id);
 }
 
 int ClientLevel::rowForId(quint32 id) const
 {
     int row = 0;
     for (auto it = m_clients.constBegin();
             it != m_clients.constEnd();
             ++it, ++row) {
         if (it.key() == id) {
             return row;
         }
     }
     return -1;
 }
 
 AbstractClient *ClientLevel::clientForId(quint32 child) const
 {
     auto it = m_clients.constFind(child);
     if (it == m_clients.constEnd()) {
         return nullptr;
     }
     return it.value();
 }
 
 bool ClientLevel::containsClient(AbstractClient *client) const
 {
     for (auto it = m_clients.constBegin();
             it != m_clients.constEnd();
             ++it) {
         if (it.value() == client) {
             return true;
         }
     }
     return false;
 }
 
 const AbstractLevel *ClientLevel::levelForId(quint32 id) const
 {
     if (id == AbstractLevel::id()) {
         return this;
     }
     return nullptr;
 }
 
 AbstractLevel *ClientLevel::parentForId(quint32 child) const
 {
     if (child == id()) {
         return parentLevel();
     }
     if (m_clients.contains(child)) {
         return const_cast<ClientLevel*>(this);
     }
     return nullptr;
 }
 
 AbstractLevel *AbstractLevel::create(const QList< ClientModel::LevelRestriction > &restrictions, ClientModel::LevelRestrictions parentRestrictions, ClientModel *model, AbstractLevel *parent)
 {
     if (restrictions.isEmpty() || restrictions.first() == ClientModel::NoRestriction) {
         ClientLevel *leaf = new ClientLevel(model, parent);
         leaf->setRestrictions(parentRestrictions);
         if (!parent) {
             leaf->setParent(model);
         }
         return leaf;
     }
     // create a level
     QList<ClientModel::LevelRestriction> childRestrictions(restrictions);
     ClientModel::LevelRestriction restriction = childRestrictions.takeFirst();
     ClientModel::LevelRestrictions childrenRestrictions = restriction | parentRestrictions;
     ForkLevel *currentLevel = new ForkLevel(childRestrictions, model, parent);
     currentLevel->setRestrictions(childrenRestrictions);
     currentLevel->setRestriction(restriction);
     if (!parent) {
         currentLevel->setParent(model);
     }
     switch (restriction) {
     case ClientModel::ActivityRestriction: {
 #ifdef KWIN_BUILD_ACTIVITIES
         if (Activities::self()) {
             const QStringList &activities = Activities::self()->all();
             for (QStringList::const_iterator it = activities.begin(); it != activities.end(); ++it) {
                 AbstractLevel *childLevel = create(childRestrictions, childrenRestrictions, model, currentLevel);
                 if (!childLevel) {
                     continue;
                 }
                 childLevel->setActivity(*it);
                 currentLevel->addChild(childLevel);
             }
         }
         break;
 #else
         return nullptr;
 #endif
     }
     case ClientModel::ScreenRestriction:
         for (int i=0; i<screens()->count(); ++i) {
             AbstractLevel *childLevel = create(childRestrictions, childrenRestrictions, model, currentLevel);
             if (!childLevel) {
                 continue;
             }
             childLevel->setScreen(i);
             currentLevel->addChild(childLevel);
         }
         break;
     case ClientModel::VirtualDesktopRestriction:
         for (uint i=1; i<=VirtualDesktopManager::self()->count(); ++i) {
             AbstractLevel *childLevel = create(childRestrictions, childrenRestrictions, model, currentLevel);
             if (!childLevel) {
                 continue;
             }
             childLevel->setVirtualDesktop(i);
             currentLevel->addChild(childLevel);
         }
         break;
     default:
         // invalid
         return nullptr;
     }
 
     return currentLevel;
 }
 
 AbstractLevel::AbstractLevel(ClientModel *model, AbstractLevel *parent)
     : QObject(parent)
     , m_model(model)
     , m_parent(parent)
     , m_screen(0)
     , m_virtualDesktop(0)
     , m_activity()
     , m_restriction(ClientModel::ClientModel::NoRestriction)
     , m_restrictions(ClientModel::NoRestriction)
     , m_id(nextId())
 {
 }
 
 AbstractLevel::~AbstractLevel()
 {
 }
 
 void AbstractLevel::setRestriction(ClientModel::LevelRestriction restriction)
 {
     m_restriction = restriction;
 }
 
 void AbstractLevel::setActivity(const QString &activity)
 {
     m_activity = activity;
 }
 
 void AbstractLevel::setScreen(uint screen)
 {
     m_screen = screen;
 }
 
 void AbstractLevel::setVirtualDesktop(uint virtualDesktop)
 {
     m_virtualDesktop = virtualDesktop;
 }
 
 void AbstractLevel::setRestrictions(ClientModel::LevelRestrictions restrictions)
 {
     m_restrictions = restrictions;
 }
 
 ForkLevel::ForkLevel(const QList<ClientModel::LevelRestriction> &childRestrictions, ClientModel *model, AbstractLevel *parent)
     : AbstractLevel(model, parent)
     , m_childRestrictions(childRestrictions)
 {
     connect(VirtualDesktopManager::self(), SIGNAL(countChanged(uint,uint)), SLOT(desktopCountChanged(uint,uint)));
     connect(screens(), SIGNAL(countChanged(int,int)), SLOT(screenCountChanged(int,int)));
 #ifdef KWIN_BUILD_ACTIVITIES
     if (Activities *activities = Activities::self()) {
         connect(activities, SIGNAL(added(QString)), SLOT(activityAdded(QString)));
         connect(activities, SIGNAL(removed(QString)), SLOT(activityRemoved(QString)));
     }
 #endif
 }
 
 ForkLevel::~ForkLevel()
 {
 }
 
 void ForkLevel::desktopCountChanged(uint previousCount, uint newCount)
 {
     if (restriction() != ClientModel::ClientModel::VirtualDesktopRestriction) {
         return;
     }
     if (previousCount != uint(count())) {
         return;
     }
     if (previousCount > newCount) {
         // desktops got removed
         emit beginRemove(newCount, previousCount-1, id());
         while (uint(m_children.count()) > newCount) {
             delete m_children.takeLast();
         }
         emit endRemove();
     } else {
         // desktops got added
         emit beginInsert(previousCount, newCount-1, id());
         for (uint i=previousCount+1; i<=newCount; ++i) {
             AbstractLevel *childLevel = AbstractLevel::create(m_childRestrictions, restrictions(), model(), this);
             if (!childLevel) {
                 continue;
             }
             childLevel->setVirtualDesktop(i);
             childLevel->init();
             addChild(childLevel);
         }
         emit endInsert();
     }
 }
 
 void ForkLevel::screenCountChanged(int previousCount, int newCount)
 {
     if (restriction() != ClientModel::ClientModel::ClientModel::ScreenRestriction) {
         return;
     }
     if (newCount == previousCount || previousCount != count()) {
         return;
     }
 
     if (previousCount > newCount) {
         // screens got removed
         emit beginRemove(newCount, previousCount-1, id());
         while (m_children.count() > newCount) {
             delete m_children.takeLast();
         }
         emit endRemove();
     } else {
         // screens got added
         emit beginInsert(previousCount, newCount-1, id());
         for (int i=previousCount; i<newCount; ++i) {
             AbstractLevel *childLevel = AbstractLevel::create(m_childRestrictions, restrictions(), model(), this);
             if (!childLevel) {
                 continue;
             }
             childLevel->setScreen(i);
             childLevel->init();
             addChild(childLevel);
         }
         emit endInsert();
     }
 }
 
 void ForkLevel::activityAdded(const QString &activityId)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (restriction() != ClientModel::ClientModel::ActivityRestriction) {
         return;
     }
     // verify that our children do not contain this activity
     foreach (AbstractLevel *child, m_children) {
         if (child->activity() == activityId) {
             return;
         }
     }
     emit beginInsert(m_children.count(), m_children.count(), id());
     AbstractLevel *childLevel = AbstractLevel::create(m_childRestrictions, restrictions(), model(), this);
     if (!childLevel) {
         emit endInsert();
         return;
     }
     childLevel->setActivity(activityId);
     childLevel->init();
     addChild(childLevel);
     emit endInsert();
 #else
     Q_UNUSED(activityId)
 #endif
 }
 
 void ForkLevel::activityRemoved(const QString &activityId)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (restriction() != ClientModel::ClientModel::ActivityRestriction) {
         return;
     }
     for (int i=0; i<m_children.length(); ++i) {
         if (m_children.at(i)->activity() == activityId) {
             emit beginRemove(i, i, id());
             delete m_children.takeAt(i);
             emit endRemove();
             break;
         }
     }
 #else
     Q_UNUSED(activityId)
 #endif
 }
 
 int ForkLevel::count() const
 {
     return m_children.count();
 }
 
 void ForkLevel::addChild(AbstractLevel *child)
 {
     m_children.append(child);
     connect(child, SIGNAL(beginInsert(int,int,quint32)), SIGNAL(beginInsert(int,int,quint32)));
     connect(child, SIGNAL(beginRemove(int,int,quint32)), SIGNAL(beginRemove(int,int,quint32)));
     connect(child, SIGNAL(endInsert()), SIGNAL(endInsert()));
     connect(child, SIGNAL(endRemove()), SIGNAL(endRemove()));
 }
 
 void ForkLevel::setActivity(const QString &activity)
 {
     AbstractLevel::setActivity(activity);
     for (QList<AbstractLevel*>::iterator it = m_children.begin(); it != m_children.end(); ++it) {
         (*it)->setActivity(activity);
     }
 }
 
 void ForkLevel::setScreen(uint screen)
 {
     AbstractLevel::setScreen(screen);
     for (QList<AbstractLevel*>::iterator it = m_children.begin(); it != m_children.end(); ++it) {
         (*it)->setScreen(screen);
     }
 }
 
 void ForkLevel::setVirtualDesktop(uint virtualDesktop)
 {
     AbstractLevel::setVirtualDesktop(virtualDesktop);
     for (QList<AbstractLevel*>::iterator it = m_children.begin(); it != m_children.end(); ++it) {
         (*it)->setVirtualDesktop(virtualDesktop);
     }
 }
 
 void ForkLevel::init()
 {
     for (QList<AbstractLevel*>::iterator it = m_children.begin(); it != m_children.end(); ++it) {
         (*it)->init();
     }
 }
 
 quint32 ForkLevel::idForRow(int row) const
 {
     if (row >= m_children.length()) {
         return 0;
     }
     return m_children.at(row)->id();
 }
 
 const AbstractLevel *ForkLevel::levelForId(quint32 id) const
 {
     if (id == AbstractLevel::id()) {
         return this;
     }
     for (QList<AbstractLevel*>::const_iterator it = m_children.constBegin(); it != m_children.constEnd(); ++it) {
         if (const AbstractLevel *child = (*it)->levelForId(id)) {
             return child;
         }
     }
     // not found
     return nullptr;
 }
 
 AbstractLevel *ForkLevel::parentForId(quint32 child) const
 {
     if (child == id()) {
         return parentLevel();
     }
     for (QList<AbstractLevel*>::const_iterator it = m_children.constBegin(); it != m_children.constEnd(); ++it) {
         if (AbstractLevel *parent = (*it)->parentForId(child)) {
             return parent;
         }
     }
     // not found
     return nullptr;
 }
 
 int ForkLevel::rowForId(quint32 child) const
 {
     if (id() == child) {
         return 0;
     }
     for (int i=0; i<m_children.count(); ++i) {
         if (m_children.at(i)->id() == child) {
             return i;
         }
     }
     // do recursion
     for (QList<AbstractLevel*>::const_iterator it = m_children.constBegin(); it != m_children.constEnd(); ++it) {
         int row = (*it)->rowForId(child);
         if (row != -1) {
             return  row;
         }
     }
     // not found
     return -1;
 }
 
 AbstractClient *ForkLevel::clientForId(quint32 child) const
 {
     for (QList<AbstractLevel*>::const_iterator it = m_children.constBegin(); it != m_children.constEnd(); ++it) {
         if (AbstractClient *client = (*it)->clientForId(child)) {
             return client;
         }
     }
     // not found
     return nullptr;
 }
 
 ClientModel::ClientModel(QObject *parent)
     : QAbstractItemModel(parent)
     , m_root(nullptr)
     , m_exclusions(NoExclusion)
 {
 }
 
 ClientModel::~ClientModel()
 {
 }
 
 void ClientModel::setLevels(QList< ClientModel::LevelRestriction > restrictions)
 {
     beginResetModel();
     if (m_root) {
         delete m_root;
     }
     m_root = AbstractLevel::create(restrictions, NoRestriction, this);
     connect(m_root, SIGNAL(beginInsert(int,int,quint32)), SLOT(levelBeginInsert(int,int,quint32)));
     connect(m_root, SIGNAL(beginRemove(int,int,quint32)), SLOT(levelBeginRemove(int,int,quint32)));
     connect(m_root, SIGNAL(endInsert()), SLOT(levelEndInsert()));
     connect(m_root, SIGNAL(endRemove()), SLOT(levelEndRemove()));
     m_root->init();
     endResetModel();
 }
 
 void ClientModel::setExclusions(ClientModel::Exclusions exclusions)
 {
     if (exclusions == m_exclusions) {
         return;
     }
     m_exclusions = exclusions;
     emit exclusionsChanged();
 }
 
 QVariant ClientModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid() || index.column() != 0) {
         return QVariant();
     }
     if (const AbstractLevel *level = getLevel(index)) {
         LevelRestriction restriction = level->restriction();
         if (restriction == ActivityRestriction && (role == Qt::DisplayRole || role == ActivityRole)) {
             return level->activity();
         } else if (restriction == VirtualDesktopRestriction && (role == Qt::DisplayRole || role == DesktopRole)) {
             return level->virtualDesktop();
         } else if (restriction ==ScreenRestriction && (role == Qt::DisplayRole || role == ScreenRole)) {
             return level->screen();
         } else {
             return QVariant();
         }
     }
     if (role == Qt::DisplayRole || role == ClientRole) {
         if (AbstractClient *client = m_root->clientForId(index.internalId())) {
             return QVariant::fromValue(client);
         }
     }
     return QVariant();
 }
 
 int ClientModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 int ClientModel::rowCount(const QModelIndex &parent) const
 {
     if (!m_root) {
         return 0;
     }
     if (!parent.isValid()) {
         return m_root->count();
     }
     if (const AbstractLevel *level = getLevel(parent)) {
         if (level->id() != parent.internalId()) {
             // not a real level - no children
             return 0;
         }
         return level->count();
     }
     return 0;
 }
 
 QHash<int, QByteArray> ClientModel::roleNames() const
 {
     return {
         { Qt::DisplayRole, QByteArrayLiteral("display") },
         { ClientRole, QByteArrayLiteral("client") },
         { ScreenRole, QByteArrayLiteral("screen") },
         { DesktopRole, QByteArrayLiteral("desktop") },
         { ActivityRole, QByteArrayLiteral("activity") },
     };
 }
 
 QModelIndex ClientModel::parent(const QModelIndex &child) const
 {
     if (!child.isValid() || child.column() != 0) {
         return QModelIndex();
     }
     return parentForId(child.internalId());
 }
 
 QModelIndex ClientModel::parentForId(quint32 childId) const
 {
     if (childId == m_root->id()) {
         // asking for parent of our toplevel
         return QModelIndex();
     }
     if (AbstractLevel *parentLevel = m_root->parentForId(childId)) {
         if (parentLevel == m_root) {
             return QModelIndex();
         }
         const int row = m_root->rowForId(parentLevel->id());
         if (row == -1) {
             // error
             return QModelIndex();
         }
         return createIndex(row, 0, parentLevel->id());
     }
     return QModelIndex();
 }
 
 QModelIndex ClientModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (column != 0 || row < 0 || !m_root) {
         return QModelIndex();
     }
     if (!parent.isValid()) {
         if (row >= rowCount()) {
             return QModelIndex();
         }
         return createIndex(row, 0, m_root->idForRow(row));
     }
     const AbstractLevel *parentLevel = getLevel(parent);
     if (!parentLevel) {
         return QModelIndex();
     }
     if (row >= parentLevel->count()) {
         return QModelIndex();
     }
     const quint32 id = parentLevel->idForRow(row);
     if (id == 0) {
         return QModelIndex();
     }
     return createIndex(row, column, id);
 }
 
 const AbstractLevel *ClientModel::getLevel(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return m_root;
     }
     return m_root->levelForId(index.internalId());
 }
 
 void ClientModel::levelBeginInsert(int rowStart, int rowEnd, quint32 id)
 {
     const int row = m_root->rowForId(id);
     QModelIndex parent;
     if (row != -1) {
         parent = createIndex(row, 0, id);
     }
     beginInsertRows(parent, rowStart, rowEnd);
 }
 
 void ClientModel::levelBeginRemove(int rowStart, int rowEnd, quint32 id)
 {
     const int row = m_root->rowForId(id);
     QModelIndex parent;
     if (row != -1) {
         parent = createIndex(row, 0, id);
     }
     beginRemoveRows(parent, rowStart, rowEnd);
 }
 
 void ClientModel::levelEndInsert()
 {
     endInsertRows();
 }
 
 void ClientModel::levelEndRemove()
 {
     endRemoveRows();
 }
 
 #define CLIENT_MODEL_WRAPPER(name, levels) \
 name::name(QObject *parent) \
     : ClientModel(parent) \
 { \
     setLevels(levels); \
 } \
 name::~name() {}
 
 CLIENT_MODEL_WRAPPER(SimpleClientModel, QList<LevelRestriction>())
 CLIENT_MODEL_WRAPPER(ClientModelByScreen, QList<LevelRestriction>() << ScreenRestriction)
 CLIENT_MODEL_WRAPPER(ClientModelByScreenAndDesktop, QList<LevelRestriction>() << ScreenRestriction << VirtualDesktopRestriction)
 #undef CLIENT_MODEL_WRAPPER
 
 ClientFilterModel::ClientFilterModel(QObject *parent)
     : QSortFilterProxyModel(parent)
     , m_clientModel(nullptr)
 {
 }
 
 ClientFilterModel::~ClientFilterModel()
 {
 }
 
 void ClientFilterModel::setClientModel(ClientModel *clientModel)
 {
     if (clientModel == m_clientModel) {
         return;
     }
     m_clientModel = clientModel;
     setSourceModel(m_clientModel);
     emit clientModelChanged();
 }
 
 void ClientFilterModel::setFilter(const QString &filter)
 {
     if (filter == m_filter) {
         return;
     }
     m_filter = filter;
     emit filterChanged();
     invalidateFilter();
 }
 
 bool ClientFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     if (!m_clientModel) {
         return false;
     }
     if (m_filter.isEmpty()) {
         return true;
     }
     QModelIndex index = m_clientModel->index(sourceRow, 0, sourceParent);
     if (!index.isValid()) {
         return false;
     }
     QVariant data = index.data();
     if (!data.isValid()) {
         // an invalid QVariant is valid data
         return true;
     }
     // TODO: introduce a type as a data role and properly check, this seems dangerous
     if (data.type() == QVariant::Int || data.type() == QVariant::UInt || data.type() == QVariant::String) {
         // we do not filter out screen, desktop and activity
         return true;
     }
     X11Client *client = qvariant_cast<KWin::X11Client *>(data);
     if (!client) {
         return false;
     }
     if (client->caption().contains(m_filter, Qt::CaseInsensitive)) {
         return true;
     }
     const QString windowRole(QString::fromUtf8(client->windowRole()));
     if (windowRole.contains(m_filter, Qt::CaseInsensitive)) {
         return true;
     }
     const QString resourceName(QString::fromUtf8(client->resourceName()));
     if (resourceName.contains(m_filter, Qt::CaseInsensitive)) {
         return true;
     }
     const QString resourceClass(QString::fromUtf8(client->resourceClass()));
     if (resourceClass.contains(m_filter, Qt::CaseInsensitive)) {
         return true;
     }
     return false;
 }
 
 } // namespace Scripting
 } // namespace KWin
diff --git a/thumbnailitem.cpp b/thumbnailitem.cpp
index b5c0e81d6..85e2d48b3 100644
--- a/thumbnailitem.cpp
+++ b/thumbnailitem.cpp
@@ -1,221 +1,220 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "thumbnailitem.h"
 // KWin
 #include "x11client.h"
 #include "composite.h"
 #include "effects.h"
 #include "workspace.h"
-#include "xdgshellclient.h"
 #include "wayland_server.h"
 // Qt
 #include <QDebug>
 #include <QPainter>
 #include <QQuickWindow>
 
 namespace KWin
 {
 
 AbstractThumbnailItem::AbstractThumbnailItem(QQuickItem *parent)
     : QQuickPaintedItem(parent)
     , m_brightness(1.0)
     , m_saturation(1.0)
     , m_clipToItem()
 {
     connect(Compositor::self(), SIGNAL(compositingToggled(bool)), SLOT(compositingToggled()));
     compositingToggled();
     QTimer::singleShot(0, this, SLOT(init()));
 }
 
 AbstractThumbnailItem::~AbstractThumbnailItem()
 {
 }
 
 void AbstractThumbnailItem::compositingToggled()
 {
     m_parent.clear();
     if (effects) {
         connect(effects, SIGNAL(windowAdded(KWin::EffectWindow*)), SLOT(effectWindowAdded()));
         connect(effects, SIGNAL(windowDamaged(KWin::EffectWindow*,QRect)), SLOT(repaint(KWin::EffectWindow*)));
         effectWindowAdded();
     }
 }
 
 void AbstractThumbnailItem::init()
 {
     findParentEffectWindow();
     if (m_parent) {
         m_parent->registerThumbnail(this);
     }
 }
 
 void AbstractThumbnailItem::findParentEffectWindow()
 {
     if (effects) {
         QQuickWindow *qw = window();
         if (!qw) {
             qCDebug(KWIN_CORE) << "No QQuickWindow assigned yet";
             return;
         }
         if (auto *w = static_cast<EffectWindowImpl*>(effects->findWindow(qw))) {
             m_parent = QPointer<EffectWindowImpl>(w);
         }
     }
 }
 
 void AbstractThumbnailItem::effectWindowAdded()
 {
     // the window might be added before the EffectWindow is created
     // by using this slot we can register the thumbnail when it is finally created
     if (m_parent.isNull()) {
         findParentEffectWindow();
         if (m_parent) {
             m_parent->registerThumbnail(this);
         }
     }
 }
 
 void AbstractThumbnailItem::setBrightness(qreal brightness)
 {
     if (qFuzzyCompare(brightness, m_brightness)) {
         return;
     }
     m_brightness = brightness;
     update();
     emit brightnessChanged();
 }
 
 void AbstractThumbnailItem::setSaturation(qreal saturation)
 {
     if (qFuzzyCompare(saturation, m_saturation)) {
         return;
     }
     m_saturation = saturation;
     update();
     emit saturationChanged();
 }
 
 void AbstractThumbnailItem::setClipTo(QQuickItem *clip)
 {
     m_clipToItem = QPointer<QQuickItem>(clip);
     emit clipToChanged();
 }
 
 WindowThumbnailItem::WindowThumbnailItem(QQuickItem* parent)
     : AbstractThumbnailItem(parent)
     , m_wId(nullptr)
     , m_client(nullptr)
 {
 }
 
 WindowThumbnailItem::~WindowThumbnailItem()
 {
 }
 
 void WindowThumbnailItem::setWId(const QUuid &wId)
 {
     if (m_wId == wId) {
         return;
     }
     m_wId = wId;
     if (m_wId != nullptr) {
         setClient(workspace()->findAbstractClient([this] (const AbstractClient *c) { return c->internalId() == m_wId; }));
     } else if (m_client) {
         m_client = nullptr;
         emit clientChanged();
     }
     emit wIdChanged(wId);
 }
 
 void WindowThumbnailItem::setClient(AbstractClient *client)
 {
     if (m_client == client) {
         return;
     }
     m_client = client;
     if (m_client) {
         setWId(m_client->internalId());
     } else {
         setWId({});
     }
     emit clientChanged();
 }
 
 void WindowThumbnailItem::paint(QPainter *painter)
 {
     if (effects) {
         return;
     }
     auto client = workspace()->findAbstractClient([this] (const AbstractClient *c) { return c->internalId() == m_wId; });
     if (!client) {
         return;
     }
     QPixmap pixmap = client->icon().pixmap(boundingRect().size().toSize());
     const QSize size(boundingRect().size().toSize() - pixmap.size());
     painter->drawPixmap(boundingRect().adjusted(size.width()/2.0, size.height()/2.0, -size.width()/2.0, -size.height()/2.0).toRect(),
                         pixmap);
 }
 
 void WindowThumbnailItem::repaint(KWin::EffectWindow *w)
 {
     if (static_cast<KWin::EffectWindowImpl*>(w)->window()->internalId() == m_wId) {
         update();
     }
 }
 
 DesktopThumbnailItem::DesktopThumbnailItem(QQuickItem *parent)
     : AbstractThumbnailItem(parent)
     , m_desktop(0)
 {
 }
 
 DesktopThumbnailItem::~DesktopThumbnailItem()
 {
 }
 
 void DesktopThumbnailItem::setDesktop(int desktop)
 {
     desktop = qBound<int>(1, desktop, VirtualDesktopManager::self()->count());
     if (desktop == m_desktop) {
         return;
     }
     m_desktop = desktop;
     update();
     emit desktopChanged(m_desktop);
 }
 
 void DesktopThumbnailItem::paint(QPainter *painter)
 {
     Q_UNUSED(painter)
     if (effects) {
         return;
     }
     // TODO: render icon
 }
 
 void DesktopThumbnailItem::repaint(EffectWindow *w)
 {
     if (w->isOnDesktop(m_desktop)) {
         update();
     }
 }
 
 } // namespace KWin
diff --git a/useractions.cpp b/useractions.cpp
index cdae43117..00cbc54a0 100644
--- a/useractions.cpp
+++ b/useractions.cpp
@@ -1,1746 +1,1745 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 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/>.
 *********************************************************************/
 
 /*
 
  This file contains things relevant to direct user actions, such as
  responses to global keyboard shortcuts, or selecting actions
  from the window operations menu.
 
 */
 
 ///////////////////////////////////////////////////////////////////////////////
 // NOTE: if you change the menu, keep
 //       plasma-desktop/applets/taskmanager/package/contents/ui/ContextMenu.qml
 //       in sync
 //////////////////////////////////////////////////////////////////////////////
 
 #include "useractions.h"
 #include "cursor.h"
 #include "x11client.h"
 #include "colorcorrection/manager.h"
 #include "composite.h"
 #include "input.h"
 #include "workspace.h"
 #include "effects.h"
 #include "platform.h"
 #include "screens.h"
-#include "xdgshellclient.h"
 #include "virtualdesktops.h"
 #include "scripting/scripting.h"
 
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #include <kactivities/info.h>
 #endif
 #include "appmenu.h"
 
 #include <KProcess>
 
 #include <QAction>
 #include <QCheckBox>
 #include <QtConcurrentRun>
 #include <QPointer>
 #include <QPushButton>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <kconfig.h>
 #include <QRegExp>
 #include <QMenu>
 #include <QWidgetAction>
 #include <kauthorized.h>
 
 #include "killwindow.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 
 namespace KWin
 {
 
 UserActionsMenu::UserActionsMenu(QObject *parent)
     : QObject(parent)
     , m_menu(nullptr)
     , m_desktopMenu(nullptr)
     , m_screenMenu(nullptr)
     , m_activityMenu(nullptr)
     , m_scriptsMenu(nullptr)
     , m_resizeOperation(nullptr)
     , m_moveOperation(nullptr)
     , m_maximizeOperation(nullptr)
     , m_shadeOperation(nullptr)
     , m_keepAboveOperation(nullptr)
     , m_keepBelowOperation(nullptr)
     , m_fullScreenOperation(nullptr)
     , m_noBorderOperation(nullptr)
     , m_minimizeOperation(nullptr)
     , m_closeOperation(nullptr)
 {
 }
 
 UserActionsMenu::~UserActionsMenu()
 {
     discard();
 }
 
 bool UserActionsMenu::isShown() const
 {
     return m_menu && m_menu->isVisible();
 }
 
 bool UserActionsMenu::hasClient() const
 {
     return m_client && isShown();
 }
 
 void UserActionsMenu::close()
 {
     if (!m_menu) {
         return;
     }
     m_menu->close();
     m_client.clear();
 }
 
 bool UserActionsMenu::isMenuClient(const AbstractClient *c) const
 {
     return c && c == m_client;
 }
 
 void UserActionsMenu::show(const QRect &pos, AbstractClient *client)
 {
     Q_ASSERT(client);
     QPointer<AbstractClient> cl(client);
     // Presumably client will never be nullptr,
     // but play it safe and make sure not to crash.
     if (cl.isNull()) {
         return;
     }
     if (isShown()) {  // recursion
         return;
     }
     if (cl->isDesktop() || cl->isDock()) {
         return;
     }
     if (!KAuthorized::authorizeAction(QStringLiteral("kwin_rmb"))) {
         return;
     }
     m_client = cl;
     init();
     m_client->blockActivityUpdates(true);
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         m_menu->popup(pos.bottomLeft());
     } else {
         m_menu->exec(pos.bottomLeft());
     }
     if (m_client) {
         m_client->blockActivityUpdates(false);
     }
 }
 
 void UserActionsMenu::grabInput()
 {
     m_menu->windowHandle()->setMouseGrabEnabled(true);
     m_menu->windowHandle()->setKeyboardGrabEnabled(true);
 }
 
 void UserActionsMenu::helperDialog(const QString& message, AbstractClient* client)
 {
     QStringList args;
     QString type;
     auto shortcut = [](const QString &name) {
         QAction* action = Workspace::self()->findChild<QAction*>(name);
         Q_ASSERT(action != nullptr);
         const auto shortcuts = KGlobalAccel::self()->shortcut(action);
         return QStringLiteral("%1 (%2)").arg(action->text())
                              .arg(shortcuts.isEmpty() ? QString() : shortcuts.first().toString(QKeySequence::NativeText));
     };
     if (message == QStringLiteral("noborderaltf3")) {
         args << QStringLiteral("--msgbox") << i18n(
                  "You have selected to show a window without its border.\n"
                  "Without the border, you will not be able to enable the border "
                  "again using the mouse: use the window operations menu instead, "
                  "activated using the %1 keyboard shortcut.",
                  shortcut(QStringLiteral("Window Operations Menu")));
         type = QStringLiteral("altf3warning");
     } else if (message == QLatin1String("fullscreenaltf3")) {
         args << QStringLiteral("--msgbox") << i18n(
                  "You have selected to show a window in fullscreen mode.\n"
                  "If the application itself does not have an option to turn the fullscreen "
                  "mode off you will not be able to disable it "
                  "again using the mouse: use the window operations menu instead, "
                  "activated using the %1 keyboard shortcut.",
                  shortcut(QStringLiteral("Window Operations Menu")));
         type = QStringLiteral("altf3warning");
     } else
         abort();
     if (!type.isEmpty()) {
         KConfig cfg(QStringLiteral("kwin_dialogsrc"));
         KConfigGroup cg(&cfg, "Notification Messages");  // Depends on KMessageBox
         if (!cg.readEntry(type, true))
             return;
         args << QStringLiteral("--dontagain") << QLatin1String("kwin_dialogsrc:") + type;
     }
     if (client)
         args << QStringLiteral("--embed") << QString::number(client->windowId());
     QtConcurrent::run([args]() {
         KProcess::startDetached(QStringLiteral("kdialog"), args);
     });
 }
 
 
 QStringList configModules(bool controlCenter)
 {
     QStringList args;
     args <<  QStringLiteral("kwindecoration");
     if (controlCenter)
         args << QStringLiteral("kwinoptions");
     else if (KAuthorized::authorizeControlModule(QStringLiteral("kde-kwinoptions.desktop")))
         args << QStringLiteral("kwinactions") << QStringLiteral("kwinfocus") <<  QStringLiteral("kwinmoving") << QStringLiteral("kwinadvanced")
              << QStringLiteral("kwinrules") << QStringLiteral("kwincompositing") << QStringLiteral("kwineffects")
 #ifdef KWIN_BUILD_TABBOX
              << QStringLiteral("kwintabbox")
 #endif
              << QStringLiteral("kwinscreenedges")
              << QStringLiteral("kwinscripts")
              ;
     return args;
 }
 
 void UserActionsMenu::init()
 {
     if (m_menu) {
         return;
     }
     m_menu = new QMenu;
     connect(m_menu, &QMenu::aboutToShow, this, &UserActionsMenu::menuAboutToShow);
     connect(m_menu, &QMenu::triggered, this, &UserActionsMenu::slotWindowOperation, Qt::QueuedConnection);
 
     QMenu *advancedMenu = new QMenu(m_menu);
     connect(advancedMenu, &QMenu::aboutToShow, [this, advancedMenu]() {
         if (m_client) {
             advancedMenu->setPalette(m_client->palette());
         }
     });
 
     auto setShortcut = [](QAction *action, const QString &actionName) {
         const auto shortcuts = KGlobalAccel::self()->shortcut(Workspace::self()->findChild<QAction*>(actionName));
         if (!shortcuts.isEmpty()) {
             action->setShortcut(shortcuts.first());
         }
     };
 
     m_moveOperation = advancedMenu->addAction(i18n("&Move"));
     m_moveOperation->setIcon(QIcon::fromTheme(QStringLiteral("transform-move")));
     setShortcut(m_moveOperation, QStringLiteral("Window Move"));
     m_moveOperation->setData(Options::UnrestrictedMoveOp);
 
     m_resizeOperation = advancedMenu->addAction(i18n("&Resize"));
     m_resizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("transform-scale")));
     setShortcut(m_resizeOperation, QStringLiteral("Window Resize"));
     m_resizeOperation->setData(Options::ResizeOp);
 
     m_keepAboveOperation = advancedMenu->addAction(i18n("Keep &Above Others"));
     m_keepAboveOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-keep-above")));
     setShortcut(m_keepAboveOperation, QStringLiteral("Window Above Other Windows"));
     m_keepAboveOperation->setCheckable(true);
     m_keepAboveOperation->setData(Options::KeepAboveOp);
 
     m_keepBelowOperation = advancedMenu->addAction(i18n("Keep &Below Others"));
     m_keepBelowOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-keep-below")));
     setShortcut(m_keepBelowOperation, QStringLiteral("Window Below Other Windows"));
     m_keepBelowOperation->setCheckable(true);
     m_keepBelowOperation->setData(Options::KeepBelowOp);
 
     m_fullScreenOperation = advancedMenu->addAction(i18n("&Fullscreen"));
     m_fullScreenOperation->setIcon(QIcon::fromTheme(QStringLiteral("view-fullscreen")));
     setShortcut(m_fullScreenOperation, QStringLiteral("Window Fullscreen"));
     m_fullScreenOperation->setCheckable(true);
     m_fullScreenOperation->setData(Options::FullScreenOp);
 
     m_shadeOperation = advancedMenu->addAction(i18n("&Shade"));
     m_shadeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-shade")));
     setShortcut(m_shadeOperation, QStringLiteral("Window Shade"));
     m_shadeOperation->setCheckable(true);
     m_shadeOperation->setData(Options::ShadeOp);
 
     m_noBorderOperation = advancedMenu->addAction(i18n("&No Border"));
     m_noBorderOperation->setIcon(QIcon::fromTheme(QStringLiteral("edit-none-border")));
     setShortcut(m_noBorderOperation, QStringLiteral("Window No Border"));
     m_noBorderOperation->setCheckable(true);
     m_noBorderOperation->setData(Options::NoBorderOp);
 
     advancedMenu->addSeparator();
 
     m_shortcutOperation = advancedMenu->addAction(i18n("Set Window Short&cut..."));
     m_shortcutOperation->setIcon(QIcon::fromTheme(QStringLiteral("configure-shortcuts")));
     setShortcut(m_shortcutOperation, QStringLiteral("Setup Window Shortcut"));
     m_shortcutOperation->setData(Options::SetupWindowShortcutOp);
 
     QAction *action = advancedMenu->addAction(i18n("Configure Special &Window Settings..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-windows-actions")));
     action->setData(Options::WindowRulesOp);
     m_rulesOperation = action;
 
     action = advancedMenu->addAction(i18n("Configure S&pecial Application Settings..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-windows-actions")));
     action->setData(Options::ApplicationRulesOp);
     m_applicationRulesOperation = action;
     if (!kwinApp()->config()->isImmutable() &&
             !KAuthorized::authorizeControlModules(configModules(true)).isEmpty()) {
         advancedMenu->addSeparator();
         action = advancedMenu->addAction(i18nc("Entry in context menu of window decoration to open the configuration module of KWin",
                                         "Configure W&indow Manager..."));
         action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
         connect(action, &QAction::triggered, this,
             [this]() {
                 // opens the KWin configuration
                 QStringList args;
                 args << QStringLiteral("--icon") << QStringLiteral("preferences-system-windows");
                 const QString path = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                             QStringLiteral("kservices5/kwinfocus.desktop"));
                 if (!path.isEmpty()) {
                     args << QStringLiteral("--desktopfile") << path;
                 }
                 args << configModules(false);
                 QProcess *p = new Process(this);
                 p->setArguments(args);
                 p->setProcessEnvironment(kwinApp()->processStartupEnvironment());
                 p->setProgram(QStringLiteral("kcmshell5"));
                 connect(p, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), p, &QProcess::deleteLater);
                 connect(p, &QProcess::errorOccurred, this, [p](QProcess::ProcessError e) {
                     if (e == QProcess::FailedToStart) {
                         qCDebug(KWIN_CORE) << "Failed to start kcmshell5";
                     }
                 });
                 p->start();
             }
         );
     }
 
     m_maximizeOperation = m_menu->addAction(i18n("Ma&ximize"));
     m_maximizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-maximize")));
     setShortcut(m_maximizeOperation, QStringLiteral("Window Maximize"));
     m_maximizeOperation->setCheckable(true);
     m_maximizeOperation->setData(Options::MaximizeOp);
 
     m_minimizeOperation = m_menu->addAction(i18n("Mi&nimize"));
     m_minimizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-minimize")));
     setShortcut(m_minimizeOperation, QStringLiteral("Window Minimize"));
     m_minimizeOperation->setData(Options::MinimizeOp);
 
     action = m_menu->addMenu(advancedMenu);
     action->setText(i18n("&More Actions"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("view-more-symbolic")));
 
     m_closeOperation = m_menu->addAction(i18n("&Close"));
     m_closeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-close")));
     setShortcut(m_closeOperation, QStringLiteral("Window Close"));
     m_closeOperation->setData(Options::CloseOp);
 }
 
 void UserActionsMenu::discard()
 {
     delete m_menu;
     m_menu = nullptr;
     m_desktopMenu = nullptr;
     m_multipleDesktopsMenu = nullptr;
     m_screenMenu = nullptr;
     m_activityMenu = nullptr;
     m_scriptsMenu = nullptr;
 }
 
 void UserActionsMenu::menuAboutToShow()
 {
     if (m_client.isNull() || !m_menu)
         return;
 
     if (VirtualDesktopManager::self()->count() == 1) {
         delete m_desktopMenu;
         m_desktopMenu = nullptr;
         delete m_multipleDesktopsMenu;
         m_multipleDesktopsMenu = nullptr;
     } else {
         initDesktopPopup();
     }
     if (screens()->count() == 1 || (!m_client->isMovable() && !m_client->isMovableAcrossScreens())) {
         delete m_screenMenu;
         m_screenMenu = nullptr;
     } else {
         initScreenPopup();
     }
 
     m_menu->setPalette(m_client->palette());
     m_resizeOperation->setEnabled(m_client->isResizable());
     m_moveOperation->setEnabled(m_client->isMovableAcrossScreens());
     m_maximizeOperation->setEnabled(m_client->isMaximizable());
     m_maximizeOperation->setChecked(m_client->maximizeMode() == MaximizeFull);
     m_shadeOperation->setEnabled(m_client->isShadeable());
     m_shadeOperation->setChecked(m_client->shadeMode() != ShadeNone);
     m_keepAboveOperation->setChecked(m_client->keepAbove());
     m_keepBelowOperation->setChecked(m_client->keepBelow());
     m_fullScreenOperation->setEnabled(m_client->userCanSetFullScreen());
     m_fullScreenOperation->setChecked(m_client->isFullScreen());
     m_noBorderOperation->setEnabled(m_client->userCanSetNoBorder());
     m_noBorderOperation->setChecked(m_client->noBorder());
     m_minimizeOperation->setEnabled(m_client->isMinimizable());
     m_closeOperation->setEnabled(m_client->isCloseable());
     m_shortcutOperation->setEnabled(m_client->rules()->checkShortcut(QString()).isNull());
 
     // drop the existing scripts menu
     delete m_scriptsMenu;
     m_scriptsMenu = nullptr;
     // ask scripts whether they want to add entries for the given Client
     QList<QAction*> scriptActions = Scripting::self()->actionsForUserActionMenu(m_client.data(), m_scriptsMenu);
     if (!scriptActions.isEmpty()) {
         m_scriptsMenu = new QMenu(m_menu);
         m_scriptsMenu->setPalette(m_client->palette());
         m_scriptsMenu->addActions(scriptActions);
 
         QAction *action = m_scriptsMenu->menuAction();
         // set it as the first item after desktop
         m_menu->insertAction(m_closeOperation, action);
         action->setText(i18n("&Extensions"));
     }
 
     m_rulesOperation->setEnabled(m_client->supportsWindowRules());
     m_applicationRulesOperation->setEnabled(m_client->supportsWindowRules());
 
     showHideActivityMenu();
 }
 
 void UserActionsMenu::showHideActivityMenu()
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     const QStringList &openActivities_ = Activities::self()->running();
     qCDebug(KWIN_CORE) << "activities:" << openActivities_.size();
     if (openActivities_.size() < 2) {
         delete m_activityMenu;
         m_activityMenu = nullptr;
     } else {
         initActivityPopup();
     }
 #endif
 }
 
 void UserActionsMenu::initDesktopPopup()
 {
     if (kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
         kwinApp()->operationMode() == Application::OperationModeXwayland) {
         if (m_multipleDesktopsMenu) {
             return;
         }
 
         m_multipleDesktopsMenu = new QMenu(m_menu);
         connect(m_multipleDesktopsMenu, &QMenu::triggered, this,   &UserActionsMenu::slotToggleOnVirtualDesktop);
         connect(m_multipleDesktopsMenu, &QMenu::aboutToShow, this, &UserActionsMenu::multipleDesktopsPopupAboutToShow);
 
         QAction *action = m_multipleDesktopsMenu->menuAction();
         // set it as the first item
         m_menu->insertAction(m_maximizeOperation, action);
         action->setText(i18n("&Desktops"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("virtual-desktops")));
 
     } else {
         if (m_desktopMenu)
             return;
 
         m_desktopMenu = new QMenu(m_menu);
         connect(m_desktopMenu, &QMenu::triggered,   this, &UserActionsMenu::slotSendToDesktop);
         connect(m_desktopMenu, &QMenu::aboutToShow, this, &UserActionsMenu::desktopPopupAboutToShow);
 
         QAction *action = m_desktopMenu->menuAction();
         // set it as the first item
         m_menu->insertAction(m_maximizeOperation, action);
         action->setText(i18n("Move to &Desktop"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("virtual-desktops")));
     }
 }
 
 void UserActionsMenu::initScreenPopup()
 {
     if (m_screenMenu) {
         return;
     }
 
     m_screenMenu = new QMenu(m_menu);
     connect(m_screenMenu, &QMenu::triggered,   this, &UserActionsMenu::slotSendToScreen);
     connect(m_screenMenu, &QMenu::aboutToShow, this, &UserActionsMenu::screenPopupAboutToShow);
 
     QAction *action = m_screenMenu->menuAction();
     // set it as the first item after desktop
     m_menu->insertAction(m_activityMenu ? m_activityMenu->menuAction() : m_minimizeOperation, action);
     action->setText(i18n("Move to &Screen"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("computer")));
 }
 
 void UserActionsMenu::initActivityPopup()
 {
     if (m_activityMenu)
         return;
 
     m_activityMenu = new QMenu(m_menu);
     connect(m_activityMenu, &QMenu::triggered, this,   &UserActionsMenu::slotToggleOnActivity);
     connect(m_activityMenu, &QMenu::aboutToShow, this, &UserActionsMenu::activityPopupAboutToShow);
 
     QAction *action = m_activityMenu->menuAction();
     // set it as the first item
     m_menu->insertAction(m_maximizeOperation, action);
     action->setText(i18n("Show in &Activities"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("activities")));
 }
 
 void UserActionsMenu::desktopPopupAboutToShow()
 {
     if (!m_desktopMenu)
         return;
     const VirtualDesktopManager *vds = VirtualDesktopManager::self();
 
     m_desktopMenu->clear();
     if (m_client) {
         m_desktopMenu->setPalette(m_client->palette());
     }
     QActionGroup *group = new QActionGroup(m_desktopMenu);
     QAction *action = m_desktopMenu->addAction(i18n("&All Desktops"));
     action->setData(0);
     action->setCheckable(true);
     group->addAction(action);
 
     if (m_client && m_client->isOnAllDesktops()) {
         action->setChecked(true);
     }
     m_desktopMenu->addSeparator();
 
     const uint BASE = 10;
 
     for (uint i = 1; i <= vds->count(); ++i) {
         QString basic_name(QStringLiteral("%1  %2"));
         if (i < BASE) {
             basic_name.prepend(QLatin1Char('&'));
         }
         action = m_desktopMenu->addAction(basic_name.arg(i).arg(vds->name(i).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         action->setData(i);
         action->setCheckable(true);
         group->addAction(action);
 
         if (m_client && !m_client->isOnAllDesktops() && m_client->isOnDesktop(i)) {
             action->setChecked(true);
         }
     }
 
     m_desktopMenu->addSeparator();
     action = m_desktopMenu->addAction(i18nc("Create a new desktop and move there the window", "&New Desktop"));
     action->setData(vds->count() + 1);
 
     if (vds->count() >= vds->maximum())
         action->setEnabled(false);
 }
 
 void UserActionsMenu::multipleDesktopsPopupAboutToShow()
 {
     if (!m_multipleDesktopsMenu)
         return;
     const VirtualDesktopManager *vds = VirtualDesktopManager::self();
 
     m_multipleDesktopsMenu->clear();
     if (m_client) {
         m_multipleDesktopsMenu->setPalette(m_client->palette());
     }
     QAction *action = m_multipleDesktopsMenu->addAction(i18n("&All Desktops"));
     action->setData(0);
     action->setCheckable(true);
     QActionGroup *allDesktopsGroup = new QActionGroup(m_multipleDesktopsMenu);
     allDesktopsGroup->addAction(action);
 
     if (m_client && m_client->isOnAllDesktops()) {
         action->setChecked(true);
     }
     m_multipleDesktopsMenu->addSeparator();
 
 
     const uint BASE = 10;
 
     for (uint i = 1; i <= vds->count(); ++i) {
         QString basic_name(QStringLiteral("%1  %2"));
         if (i < BASE) {
             basic_name.prepend(QLatin1Char('&'));
         }
         QWidgetAction *action = new QWidgetAction(m_multipleDesktopsMenu);
         QCheckBox *box = new QCheckBox(basic_name.arg(i).arg(vds->name(i).replace(QLatin1Char('&'), QStringLiteral("&&"))), m_multipleDesktopsMenu);
         action->setDefaultWidget(box);
 
         box->setBackgroundRole(m_multipleDesktopsMenu->backgroundRole());
         box->setForegroundRole(m_multipleDesktopsMenu->foregroundRole());
         box->setPalette(m_multipleDesktopsMenu->palette());
         connect(box, &QCheckBox::clicked, action, &QAction::triggered);
         m_multipleDesktopsMenu->addAction(action);
         action->setData(i);
 
         if (m_client && !m_client->isOnAllDesktops() && m_client->isOnDesktop(i)) {
             box->setChecked(true);
         }
     }
 
     m_multipleDesktopsMenu->addSeparator();
     action = m_multipleDesktopsMenu->addAction(i18nc("Create a new desktop and move there the window", "&New Desktop"));
     action->setData(vds->count() + 1);
 
     if (vds->count() >= vds->maximum())
         action->setEnabled(false);
 }
 
 void UserActionsMenu::screenPopupAboutToShow()
 {
     if (!m_screenMenu) {
         return;
     }
     m_screenMenu->clear();
 
     if (!m_client) {
         return;
     }
     m_screenMenu->setPalette(m_client->palette());
     QActionGroup *group = new QActionGroup(m_screenMenu);
 
     for (int i = 0; i<screens()->count(); ++i) {
         // assumption: there are not more than 9 screens attached.
         QAction *action = m_screenMenu->addAction(i18nc("@item:inmenu List of all Screens to send a window to. First argument is a number, second the output identifier. E.g. Screen 1 (HDMI1)",
                                                         "Screen &%1 (%2)", (i+1), screens()->name(i)));
         action->setData(i);
         action->setCheckable(true);
         if (m_client && i == m_client->screen()) {
             action->setChecked(true);
         }
         group->addAction(action);
     }
 }
 
 void UserActionsMenu::activityPopupAboutToShow()
 {
     if (!m_activityMenu)
         return;
 
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     m_activityMenu->clear();
     if (m_client) {
         m_activityMenu->setPalette(m_client->palette());
     }
     QAction *action = m_activityMenu->addAction(i18n("&All Activities"));
     action->setData(QString());
     action->setCheckable(true);
     static QPointer<QActionGroup> allActivitiesGroup;
     if (!allActivitiesGroup) {
         allActivitiesGroup = new QActionGroup(m_activityMenu);
     }
     allActivitiesGroup->addAction(action);
 
     if (m_client && m_client->isOnAllActivities()) {
         action->setChecked(true);
     }
     m_activityMenu->addSeparator();
 
     foreach (const QString &id, Activities::self()->running()) {
         KActivities::Info activity(id);
         QString name = activity.name();
         name.replace('&', "&&");
         QWidgetAction *action = new QWidgetAction(m_activityMenu);
         QCheckBox *box = new QCheckBox(name, m_activityMenu);
         action->setDefaultWidget(box);
         const QString icon = activity.icon();
         if (!icon.isEmpty())
             box->setIcon(QIcon::fromTheme(icon));
         box->setBackgroundRole(m_activityMenu->backgroundRole());
         box->setForegroundRole(m_activityMenu->foregroundRole());
         box->setPalette(m_activityMenu->palette());
         connect(box, &QCheckBox::clicked, action, &QAction::triggered);
         m_activityMenu->addAction(action);
         action->setData(id);
 
         if (m_client && !m_client->isOnAllActivities() && m_client->isOnActivity(id)) {
             box->setChecked(true);
         }
     }
 #endif
 }
 
 void UserActionsMenu::slotWindowOperation(QAction *action)
 {
     if (!action->data().isValid())
         return;
 
     Options::WindowOperation op = static_cast< Options::WindowOperation >(action->data().toInt());
     QPointer<AbstractClient> c = m_client ? m_client : QPointer<AbstractClient>(Workspace::self()->activeClient());
     if (c.isNull())
         return;
     QString type;
     switch(op) {
     case Options::FullScreenOp:
         if (!c->isFullScreen() && c->userCanSetFullScreen())
             type = QStringLiteral("fullscreenaltf3");
         break;
     case Options::NoBorderOp:
         if (!c->noBorder() && c->userCanSetNoBorder())
             type = QStringLiteral("noborderaltf3");
         break;
     default:
         break;
     }
     if (!type.isEmpty())
         helperDialog(type, c);
     // need to delay performing the window operation as we need to have the
     // user actions menu closed before we destroy the decoration. Otherwise Qt crashes
     qRegisterMetaType<Options::WindowOperation>();
     QMetaObject::invokeMethod(workspace(), "performWindowOperation",
                               Qt::QueuedConnection,
                               Q_ARG(KWin::AbstractClient*, c),
                               Q_ARG(Options::WindowOperation, op));
 }
 
 void UserActionsMenu::slotSendToDesktop(QAction *action)
 {
     bool ok = false;
     uint desk = action->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     if (m_client.isNull())
         return;
     Workspace *ws = Workspace::self();
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     if (desk == 0) {
         // the 'on_all_desktops' menu entry
         if (m_client) {
             m_client->setOnAllDesktops(!m_client->isOnAllDesktops());
         }
         return;
     } else if (desk > vds->count()) {
         vds->setCount(desk);
     }
 
     ws->sendClientToDesktop(m_client.data(), desk, false);
 }
 
 void UserActionsMenu::slotToggleOnVirtualDesktop(QAction *action)
 {
     bool ok = false;
     uint desk = action->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     if (m_client.isNull()) {
         return;
     }
 
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     if (desk == 0) {
         // the 'on_all_desktops' menu entry
         m_client->setOnAllDesktops(!m_client->isOnAllDesktops());
         return;
     } else if (desk > vds->count()) {
         vds->setCount(desk);
     }
 
     VirtualDesktop *virtualDesktop = VirtualDesktopManager::self()->desktopForX11Id(desk);
     if (m_client->desktops().contains(virtualDesktop)) {
         m_client->leaveDesktop(virtualDesktop);
     } else {
         m_client->enterDesktop(virtualDesktop);
     }
 }
 
 void UserActionsMenu::slotSendToScreen(QAction *action)
 {
     const int screen = action->data().toInt();
     if (m_client.isNull()) {
         return;
     }
     if (screen >= screens()->count()) {
         return;
     }
 
     Workspace::self()->sendClientToScreen(m_client.data(), screen);
 }
 
 void UserActionsMenu::slotToggleOnActivity(QAction *action)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     QString activity = action->data().toString();
     if (m_client.isNull())
         return;
     if (activity.isEmpty()) {
         // the 'on_all_activities' menu entry
         m_client->setOnAllActivities(!m_client->isOnAllActivities());
         return;
     }
 
     X11Client *c = dynamic_cast<X11Client *>(m_client.data());
     if (!c) {
         return;
     }
 
     Activities::self()->toggleClientOnActivity(c, activity, false);
     if (m_activityMenu && m_activityMenu->isVisible() && m_activityMenu->actions().count()) {
         const bool isOnAll = m_client->isOnAllActivities();
         m_activityMenu->actions().at(0)->setChecked(isOnAll);
         if (isOnAll) {
             // toggleClientOnActivity interprets "on all" as "on none" and
             // susequent toggling ("off") would move the client to only that activity.
             // bug #330838 -> set all but "on all" off to "force proper usage"
             for (int i = 1; i < m_activityMenu->actions().count(); ++i) {
                 if (QWidgetAction *qwa = qobject_cast<QWidgetAction*>(m_activityMenu->actions().at(i))) {
                     if (QCheckBox *qcb = qobject_cast<QCheckBox*>(qwa->defaultWidget())) {
                         qcb->setChecked(false);
                     }
                 }
             }
         }
     }
 #else
     Q_UNUSED(action)
 #endif
 }
 
 //****************************************
 // ShortcutDialog
 //****************************************
 ShortcutDialog::ShortcutDialog(const QKeySequence& cut)
     : _shortcut(cut)
 {
     m_ui.setupUi(this);
     m_ui.keySequenceEdit->setKeySequence(cut);
     m_ui.warning->hide();
 
     // Listen to changed shortcuts
     connect(m_ui.keySequenceEdit, &QKeySequenceEdit::editingFinished, this, &ShortcutDialog::keySequenceChanged);
     connect(m_ui.clearButton, &QToolButton::clicked, [this]{
         _shortcut = QKeySequence();
     });
     m_ui.keySequenceEdit->setFocus();
 
     setWindowFlags(Qt::Popup | Qt::X11BypassWindowManagerHint);
 }
 
 void ShortcutDialog::accept()
 {
     QKeySequence seq = shortcut();
     if (!seq.isEmpty()) {
         if (seq[0] == Qt::Key_Escape) {
             reject();
             return;
         }
         if (seq[0] == Qt::Key_Space
         || (seq[0] & Qt::KeyboardModifierMask) == 0) {
             // clear
             m_ui.keySequenceEdit->clear();
             QDialog::accept();
             return;
         }
     }
     QDialog::accept();
 }
 
 void ShortcutDialog::done(int r)
 {
     QDialog::done(r);
     emit dialogDone(r == Accepted);
 }
 
 void ShortcutDialog::keySequenceChanged()
 {
     activateWindow(); // where is the kbd focus lost? cause of popup state?
     QKeySequence seq = m_ui.keySequenceEdit->keySequence();
     if (_shortcut == seq)
         return; // don't try to update the same
 
     if (seq.isEmpty()) { // clear
         _shortcut = seq;
         return;
     }
     if (seq.count() > 1) {
         seq = QKeySequence(seq[0]);
         m_ui.keySequenceEdit->setKeySequence(seq);
     }
 
     // Check if the key sequence is used currently
     QString sc = seq.toString();
     // NOTICE - seq.toString() & the entries in "conflicting" randomly get invalidated after the next call (if no sc has been set & conflicting isn't empty?!)
     QList<KGlobalShortcutInfo> conflicting = KGlobalAccel::getGlobalShortcutsByKey(seq);
     if (!conflicting.isEmpty()) {
         const KGlobalShortcutInfo &conflict = conflicting.at(0);
         m_ui.warning->setText(i18nc("'%1' is a keyboard shortcut like 'ctrl+w'",
         "<b>%1</b> is already in use", sc));
         m_ui.warning->setToolTip(i18nc("keyboard shortcut '%1' is used by action '%2' in application '%3'",
         "<b>%1</b> is used by %2 in %3", sc, conflict.friendlyName(), conflict.componentFriendlyName()));
         m_ui.warning->show();
         m_ui.keySequenceEdit->setKeySequence(shortcut());
     } else if (seq != _shortcut) {
         m_ui.warning->hide();
         if (QPushButton *ok = m_ui.buttonBox->button(QDialogButtonBox::Ok))
             ok->setFocus();
     }
 
     _shortcut = seq;
 }
 
 QKeySequence ShortcutDialog::shortcut() const
 {
     return _shortcut;
 }
 
 //****************************************
 // Workspace
 //****************************************
 
 void Workspace::slotIncreaseWindowOpacity()
 {
     if (!active_client) {
         return;
     }
     active_client->setOpacity(qMin(active_client->opacity() + 0.05, 1.0));
 }
 
 void Workspace::slotLowerWindowOpacity()
 {
     if (!active_client) {
         return;
     }
     active_client->setOpacity(qMax(active_client->opacity() - 0.05, 0.05));
 }
 
 void Workspace::closeActivePopup()
 {
     if (active_popup) {
         active_popup->close();
         active_popup = nullptr;
         active_popup_client = nullptr;
     }
     m_userActionsMenu->close();
 }
 
 
 template <typename Slot>
 void Workspace::initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut, Slot slot, const QVariant &data)
 {
     initShortcut(actionName, description, shortcut, this, slot, data);
 }
 
 template <typename T, typename Slot>
 void Workspace::initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut, T *receiver, Slot slot, const QVariant &data)
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(actionName);
     a->setText(description);
     if (data.isValid()) {
         a->setData(data);
     }
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << shortcut);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << shortcut);
     input()->registerShortcut(shortcut, a, receiver, slot);
 }
 
 /**
  * Creates the global accel object \c keys.
  */
 void Workspace::initShortcuts()
 {
 #define IN_KWIN
 #include "kwinbindings.cpp"
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->initShortcuts();
 #endif
     VirtualDesktopManager::self()->initShortcuts();
     kwinApp()->platform()->colorCorrectManager()->initShortcuts();
     m_userActionsMenu->discard(); // so that it's recreated next time
 }
 
 void Workspace::setupWindowShortcut(AbstractClient* c)
 {
     Q_ASSERT(client_keys_dialog == nullptr);
     // TODO: PORT ME (KGlobalAccel related)
     //keys->setEnabled( false );
     //disable_shortcuts_keys->setEnabled( false );
     //client_keys->setEnabled( false );
     client_keys_dialog = new ShortcutDialog(c->shortcut());
     client_keys_client = c;
     connect(client_keys_dialog, &ShortcutDialog::dialogDone, this, &Workspace::setupWindowShortcutDone);
     QRect r = clientArea(ScreenArea, c);
     QSize size = client_keys_dialog->sizeHint();
     QPoint pos = c->pos() + c->clientPos();
     if (pos.x() + size.width() >= r.right())
         pos.setX(r.right() - size.width());
     if (pos.y() + size.height() >= r.bottom())
         pos.setY(r.bottom() - size.height());
     client_keys_dialog->move(pos);
     client_keys_dialog->show();
     active_popup = client_keys_dialog;
     active_popup_client = c;
 }
 
 void Workspace::setupWindowShortcutDone(bool ok)
 {
 //    keys->setEnabled( true );
 //    disable_shortcuts_keys->setEnabled( true );
 //    client_keys->setEnabled( true );
     if (ok)
         client_keys_client->setShortcut(client_keys_dialog->shortcut().toString());
     closeActivePopup();
     client_keys_dialog->deleteLater();
     client_keys_dialog = nullptr;
     client_keys_client = nullptr;
     if (active_client)
         active_client->takeFocus();
 }
 
 void Workspace::clientShortcutUpdated(AbstractClient* c)
 {
     QString key = QStringLiteral("_k_session:%1").arg(c->window());
     QAction* action = findChild<QAction*>(key);
     if (!c->shortcut().isEmpty()) {
         if (action == nullptr) { // new shortcut
             action = new QAction(this);
             kwinApp()->platform()->setupActionForGlobalAccel(action);
             action->setProperty("componentName", QStringLiteral(KWIN_NAME));
             action->setObjectName(key);
             action->setText(i18n("Activate Window (%1)", c->caption()));
             connect(action, &QAction::triggered, c, std::bind(&Workspace::activateClient, this, c, true));
         }
 
         // no autoloading, since it's configured explicitly here and is not meant to be reused
         // (the key is the window id anyway, which is kind of random)
         KGlobalAccel::self()->setShortcut(action, QList<QKeySequence>() << c->shortcut(),
                                           KGlobalAccel::NoAutoloading);
         action->setEnabled(true);
     } else {
         KGlobalAccel::self()->removeAllShortcuts(action);
         delete action;
     }
 }
 
 void Workspace::performWindowOperation(AbstractClient* c, Options::WindowOperation op)
 {
     if (!c)
         return;
     if (op == Options::MoveOp || op == Options::UnrestrictedMoveOp)
         Cursor::setPos(c->frameGeometry().center());
     if (op == Options::ResizeOp || op == Options::UnrestrictedResizeOp)
         Cursor::setPos(c->frameGeometry().bottomRight());
     switch(op) {
     case Options::MoveOp:
         c->performMouseCommand(Options::MouseMove, Cursor::pos());
         break;
     case Options::UnrestrictedMoveOp:
         c->performMouseCommand(Options::MouseUnrestrictedMove, Cursor::pos());
         break;
     case Options::ResizeOp:
         c->performMouseCommand(Options::MouseResize, Cursor::pos());
         break;
     case Options::UnrestrictedResizeOp:
         c->performMouseCommand(Options::MouseUnrestrictedResize, Cursor::pos());
         break;
     case Options::CloseOp:
         QMetaObject::invokeMethod(c, "closeWindow", Qt::QueuedConnection);
         break;
     case Options::MaximizeOp:
         c->maximize(c->maximizeMode() == MaximizeFull
                     ? MaximizeRestore : MaximizeFull);
         break;
     case Options::HMaximizeOp:
         c->maximize(c->maximizeMode() ^ MaximizeHorizontal);
         break;
     case Options::VMaximizeOp:
         c->maximize(c->maximizeMode() ^ MaximizeVertical);
         break;
     case Options::RestoreOp:
         c->maximize(MaximizeRestore);
         break;
     case Options::MinimizeOp:
         c->minimize();
         break;
     case Options::ShadeOp:
         c->performMouseCommand(Options::MouseShade, Cursor::pos());
         break;
     case Options::OnAllDesktopsOp:
         c->setOnAllDesktops(!c->isOnAllDesktops());
         break;
     case Options::FullScreenOp:
         c->setFullScreen(!c->isFullScreen(), true);
         break;
     case Options::NoBorderOp:
         c->setNoBorder(!c->noBorder());
         break;
     case Options::KeepAboveOp: {
         StackingUpdatesBlocker blocker(this);
         bool was = c->keepAbove();
         c->setKeepAbove(!c->keepAbove());
         if (was && !c->keepAbove())
             raiseClient(c);
         break;
     }
     case Options::KeepBelowOp: {
         StackingUpdatesBlocker blocker(this);
         bool was = c->keepBelow();
         c->setKeepBelow(!c->keepBelow());
         if (was && !c->keepBelow())
             lowerClient(c);
         break;
     }
     case Options::OperationsOp:
         c->performMouseCommand(Options::MouseShade, Cursor::pos());
         break;
     case Options::WindowRulesOp:
         RuleBook::self()->edit(c, false);
         break;
     case Options::ApplicationRulesOp:
         RuleBook::self()->edit(c, true);
         break;
     case Options::SetupWindowShortcutOp:
         setupWindowShortcut(c);
         break;
     case Options::LowerOp:
         lowerClient(c);
         break;
     case Options::NoOp:
         break;
     }
 }
 
 /**
  * Called by the decoration in the new API to determine what buttons the user has configured for
  * window tab dragging and the operations menu.
  */
 Options::WindowOperation X11Client::mouseButtonToWindowOperation(Qt::MouseButtons button)
 {
     Options::MouseCommand com = Options::MouseNothing;
     bool active = isActive();
     if (!wantsInput())   // we cannot be active, use it anyway
         active = true;
 
     if (button == Qt::LeftButton)
         com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();
     else if (button == Qt::MidButton)
         com = active ? options->commandActiveTitlebar2() : options->commandInactiveTitlebar2();
     else if (button == Qt::RightButton)
         com = active ? options->commandActiveTitlebar3() : options->commandInactiveTitlebar3();
 
     if (com == Options::MouseOperationsMenu)
         return Options::OperationsOp;
     return Options::NoOp;
 }
 
 /**
  * Performs a mouse command on this client (see options.h)
  */
 bool X11Client::performMouseCommand(Options::MouseCommand command, const QPoint &globalPos)
 {
     bool replay = false;
     switch(command) {
     case Options::MouseShade :
         toggleShade();
         cancelShadeHoverTimer();
         break;
     case Options::MouseSetShade:
         setShade(ShadeNormal);
         cancelShadeHoverTimer();
         break;
     case Options::MouseUnsetShade:
         setShade(ShadeNone);
         cancelShadeHoverTimer();
         break;
     default:
         return AbstractClient::performMouseCommand(command, globalPos);
     }
     return replay;
 }
 
 void Workspace::slotActivateAttentionWindow()
 {
     if (attention_chain.count() > 0)
         activateClient(attention_chain.first());
 }
 
 static uint senderValue(QObject *sender)
 {
     QAction *act = qobject_cast<QAction*>(sender);
     bool ok = false; uint i = -1;
     if (act)
         i = act->data().toUInt(&ok);
     if (ok)
         return i;
     return -1;
 }
 
 #define USABLE_ACTIVE_CLIENT (active_client && !(active_client->isDesktop() || active_client->isDock()))
 
 void Workspace::slotWindowToDesktop(uint i)
 {
     if (USABLE_ACTIVE_CLIENT) {
         if (i < 1)
             return;
 
         if (i >= 1 && i <= VirtualDesktopManager::self()->count())
             sendClientToDesktop(active_client, i, true);
     }
 }
 
 static bool screenSwitchImpossible()
 {
     if (!screens()->isCurrentFollowsMouse())
         return false;
     QStringList args;
     args << QStringLiteral("--passivepopup") << i18n("The window manager is configured to consider the screen with the mouse on it as active one.\n"
                                      "Therefore it is not possible to switch to a screen explicitly.") << QStringLiteral("20");
     KProcess::startDetached(QStringLiteral("kdialog"), args);
     return true;
 }
 
 void Workspace::slotSwitchToScreen()
 {
     if (screenSwitchImpossible())
         return;
     const int i = senderValue(sender());
     if (i > -1)
         setCurrentScreen(i);
 }
 
 void Workspace::slotSwitchToNextScreen()
 {
     if (screenSwitchImpossible())
         return;
     setCurrentScreen((screens()->current() + 1) % screens()->count());
 }
 
 void Workspace::slotSwitchToPrevScreen()
 {
     if (screenSwitchImpossible())
         return;
     setCurrentScreen((screens()->current() + screens()->count() - 1) % screens()->count());
 }
 
 void Workspace::slotWindowToScreen()
 {
     if (USABLE_ACTIVE_CLIENT) {
         const int i = senderValue(sender());
         if (i < 0)
             return;
         if (i >= 0 && i <= screens()->count()) {
             sendClientToScreen(active_client, i);
         }
     }
 }
 
 void Workspace::slotWindowToNextScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         sendClientToScreen(active_client, (active_client->screen() + 1) % screens()->count());
 }
 
 void Workspace::slotWindowToPrevScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         sendClientToScreen(active_client, (active_client->screen() + screens()->count() - 1) % screens()->count());
 }
 
 /**
  * Maximizes the active client.
  */
 void Workspace::slotWindowMaximize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::MaximizeOp);
 }
 
 /**
  * Maximizes the active client vertically.
  */
 void Workspace::slotWindowMaximizeVertical()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::VMaximizeOp);
 }
 
 /**
  * Maximizes the active client horiozontally.
  */
 void Workspace::slotWindowMaximizeHorizontal()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::HMaximizeOp);
 }
 
 
 /**
  * Minimizes the active client.
  */
 void Workspace::slotWindowMinimize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::MinimizeOp);
 }
 
 /**
  * Shades/unshades the active client respectively.
  */
 void Workspace::slotWindowShade()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::ShadeOp);
 }
 
 /**
  * Raises the active client.
  */
 void Workspace::slotWindowRaise()
 {
     if (USABLE_ACTIVE_CLIENT)
         raiseClient(active_client);
 }
 
 /**
  * Lowers the active client.
  */
 void Workspace::slotWindowLower()
 {
     if (USABLE_ACTIVE_CLIENT) {
         lowerClient(active_client);
         // As this most likely makes the window no longer visible change the
         // keyboard focus to the next available window.
         //activateNextClient( c ); // Doesn't work when we lower a child window
         if (active_client->isActive() && options->focusPolicyIsReasonable()) {
             if (options->isNextFocusPrefersMouse()) {
                 AbstractClient *next = clientUnderMouse(active_client->screen());
                 if (next && next != active_client)
                     requestFocus(next, false);
             } else {
                 activateClient(topClientOnDesktop(VirtualDesktopManager::self()->current(), -1));
             }
         }
     }
 }
 
 /**
  * Does a toggle-raise-and-lower on the active client.
  */
 void Workspace::slotWindowRaiseOrLower()
 {
     if (USABLE_ACTIVE_CLIENT)
         raiseOrLowerClient(active_client);
 }
 
 void Workspace::slotWindowOnAllDesktops()
 {
     if (USABLE_ACTIVE_CLIENT)
         active_client->setOnAllDesktops(!active_client->isOnAllDesktops());
 }
 
 void Workspace::slotWindowFullScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::FullScreenOp);
 }
 
 void Workspace::slotWindowNoBorder()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::NoBorderOp);
 }
 
 void Workspace::slotWindowAbove()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::KeepAboveOp);
 }
 
 void Workspace::slotWindowBelow()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::KeepBelowOp);
 }
 void Workspace::slotSetupWindowShortcut()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::SetupWindowShortcutOp);
 }
 
 /**
  * Toggles show desktop.
  */
 void Workspace::slotToggleShowDesktop()
 {
     setShowingDesktop(!showingDesktop());
 }
 
 template <typename Direction>
 void windowToDesktop(AbstractClient *c)
 {
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     Workspace *ws = Workspace::self();
     Direction functor;
     // TODO: why is options->isRollOverDesktops() not honored?
     const auto desktop = functor(nullptr, true);
     if (c && !c->isDesktop()
             && !c->isDock()) {
         ws->setMoveResizeClient(c);
         vds->setCurrent(desktop);
         ws->setMoveResizeClient(nullptr);
     }
 }
 
 /**
  * Moves the active client to the next desktop.
  */
 void Workspace::slotWindowToNextDesktop()
 {
     if (USABLE_ACTIVE_CLIENT)
         windowToNextDesktop(active_client);
 }
 
 void Workspace::windowToNextDesktop(AbstractClient* c)
 {
     windowToDesktop<DesktopNext>(c);
 }
 
 /**
  * Moves the active client to the previous desktop.
  */
 void Workspace::slotWindowToPreviousDesktop()
 {
     if (USABLE_ACTIVE_CLIENT)
         windowToPreviousDesktop(active_client);
 }
 
 void Workspace::windowToPreviousDesktop(AbstractClient* c)
 {
     windowToDesktop<DesktopPrevious>(c);
 }
 
 template <typename Direction>
 void activeClientToDesktop()
 {
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     Workspace *ws = Workspace::self();
     const int current = vds->current();
     Direction functor;
     const int d = functor(current, options->isRollOverDesktops());
     if (d == current) {
         return;
     }
     ws->setMoveResizeClient(ws->activeClient());
     vds->setCurrent(d);
     ws->setMoveResizeClient(nullptr);
 }
 
 void Workspace::slotWindowToDesktopRight()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopRight>();
     }
 }
 
 void Workspace::slotWindowToDesktopLeft()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopLeft>();
     }
 }
 
 void Workspace::slotWindowToDesktopUp()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopAbove>();
     }
 }
 
 void Workspace::slotWindowToDesktopDown()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopBelow>();
     }
 }
 
 /**
  * Kill Window feature, similar to xkill.
  */
 void Workspace::slotKillWindow()
 {
     if (m_windowKiller.isNull()) {
         m_windowKiller.reset(new KillWindow());
     }
     m_windowKiller->start();
 }
 
 /**
  * Switches to the nearest window in given direction.
  */
 void Workspace::switchWindow(Direction direction)
 {
     if (!active_client)
         return;
     AbstractClient *c = active_client;
     int desktopNumber = c->isOnAllDesktops() ? VirtualDesktopManager::self()->current() : c->desktop();
 
     // Centre of the active window
     QPoint curPos(c->x() + c->width() / 2, c->y() + c->height() / 2);
 
     if (!switchWindow(c, direction, curPos, desktopNumber)) {
         auto opposite = [&] {
             switch(direction) {
             case DirectionNorth:
                 return QPoint(curPos.x(), screens()->geometry().height());
             case DirectionSouth:
                 return QPoint(curPos.x(), 0);
             case DirectionEast:
                 return QPoint(0, curPos.y());
             case DirectionWest:
                 return QPoint(screens()->geometry().width(), curPos.y());
             default:
                 Q_UNREACHABLE();
             }
         };
 
         switchWindow(c, direction, opposite(), desktopNumber);
     }
 }
 
 bool Workspace::switchWindow(AbstractClient *c, Direction direction, QPoint curPos, int d)
 {
     AbstractClient *switchTo = nullptr;
     int bestScore = 0;
 
     QList<Toplevel *> clist = stackingOrder();
     for (auto i = clist.rbegin(); i != clist.rend(); ++i) {
         auto client = qobject_cast<AbstractClient*>(*i);
         if (!client) {
             continue;
         }
         if (client->wantsTabFocus() && *i != c &&
                 client->isOnDesktop(d) && !client->isMinimized() && (*i)->isOnCurrentActivity()) {
             // Centre of the other window
             const QPoint other(client->x() + client->width() / 2, client->y() + client->height() / 2);
 
             int distance;
             int offset;
             switch(direction) {
             case DirectionNorth:
                 distance = curPos.y() - other.y();
                 offset = qAbs(other.x() - curPos.x());
                 break;
             case DirectionEast:
                 distance = other.x() - curPos.x();
                 offset = qAbs(other.y() - curPos.y());
                 break;
             case DirectionSouth:
                 distance = other.y() - curPos.y();
                 offset = qAbs(other.x() - curPos.x());
                 break;
             case DirectionWest:
                 distance = curPos.x() - other.x();
                 offset = qAbs(other.y() - curPos.y());
                 break;
             default:
                 distance = -1;
                 offset = -1;
             }
 
             if (distance > 0) {
                 // Inverse score
                 int score = distance + offset + ((offset * offset) / distance);
                 if (score < bestScore || !switchTo) {
                     switchTo = client;
                     bestScore = score;
                 }
             }
         }
     }
     if (switchTo) {
         activateClient(switchTo);
     }
 
     return switchTo;
 }
 
 /**
  * Shows the window operations popup menu for the active client.
  */
 void Workspace::slotWindowOperations()
 {
     if (!active_client)
         return;
     QPoint pos = active_client->pos() + active_client->clientPos();
     showWindowMenu(QRect(pos, pos), active_client);
 }
 
 void Workspace::showWindowMenu(const QRect &pos, AbstractClient* cl)
 {
     m_userActionsMenu->show(pos, cl);
 }
 
 void Workspace::showApplicationMenu(const QRect &pos, AbstractClient *c, int actionId)
 {
     ApplicationMenu::self()->showApplicationMenu(c->pos() + pos.bottomLeft(), c, actionId);
 }
 
 /**
  * Closes the active client.
  */
 void Workspace::slotWindowClose()
 {
     // TODO: why?
 //     if ( tab_box->isVisible())
 //         return;
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::CloseOp);
 }
 
 /**
  * Starts keyboard move mode for the active client.
  */
 void Workspace::slotWindowMove()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::UnrestrictedMoveOp);
 }
 
 /**
  * Starts keyboard resize mode for the active client.
  */
 void Workspace::slotWindowResize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::UnrestrictedResizeOp);
 }
 
 #undef USABLE_ACTIVE_CLIENT
 
 void AbstractClient::setShortcut(const QString& _cut)
 {
     QString cut = rules()->checkShortcut(_cut);
     auto updateShortcut  = [this](const QKeySequence &cut = QKeySequence()) {
         if (_shortcut == cut)
             return;
         _shortcut = cut;
         setShortcutInternal();
     };
     if (cut.isEmpty()) {
         updateShortcut();
         return;
     }
     if (cut == shortcut().toString()) {
         return; // no change
     }
 // Format:
 // base+(abcdef)<space>base+(abcdef)
 // E.g. Alt+Ctrl+(ABCDEF);Meta+X,Meta+(ABCDEF)
     if (!cut.contains(QLatin1Char('(')) && !cut.contains(QLatin1Char(')')) && !cut.contains(QLatin1String(" - "))) {
         if (workspace()->shortcutAvailable(cut, this))
             updateShortcut(QKeySequence(cut));
         else
             updateShortcut();
         return;
     }
     QList< QKeySequence > keys;
     QStringList groups = cut.split(QStringLiteral(" - "));
     for (QStringList::ConstIterator it = groups.constBegin();
             it != groups.constEnd();
             ++it) {
         QRegExp reg(QStringLiteral("(.*\\+)\\((.*)\\)"));
         if (reg.indexIn(*it) > -1) {
             QString base = reg.cap(1);
             QString list = reg.cap(2);
             for (int i = 0;
                     i < list.length();
                     ++i) {
                 QKeySequence c(base + list[ i ]);
                 if (!c.isEmpty())
                     keys.append(c);
             }
         } else {
             // regexp doesn't match, so it should be a normal shortcut
             QKeySequence c(*it);
             if (!c.isEmpty()) {
                 keys.append(c);
             }
         }
     }
     for (auto it = keys.constBegin();
             it != keys.constEnd();
             ++it) {
         if (_shortcut == *it)   // current one is in the list
             return;
     }
     for (auto it = keys.constBegin();
             it != keys.constEnd();
             ++it) {
         if (workspace()->shortcutAvailable(*it, this)) {
             updateShortcut(*it);
             return;
         }
     }
     updateShortcut();
 }
 
 void AbstractClient::setShortcutInternal()
 {
     updateCaption();
     workspace()->clientShortcutUpdated(this);
 }
 
 void X11Client::setShortcutInternal()
 {
     updateCaption();
 #if 0
     workspace()->clientShortcutUpdated(this);
 #else
     // Workaround for kwin<->kglobalaccel deadlock, when KWin has X grab and the kded
     // kglobalaccel module tries to create the key grab. KWin should preferably grab
     // they keys itself anyway :(.
     QTimer::singleShot(0, this, std::bind(&Workspace::clientShortcutUpdated, workspace(), this));
 #endif
 }
 
 bool Workspace::shortcutAvailable(const QKeySequence &cut, AbstractClient* ignore) const
 {
     if (ignore && cut == ignore->shortcut())
         return true;
 
     if (!KGlobalAccel::getGlobalShortcutsByKey(cut).isEmpty()) {
         return false;
     }
     for (auto it = m_allClients.constBegin();
             it != m_allClients.constEnd();
             ++it) {
         if ((*it) != ignore && (*it)->shortcut() == cut)
             return false;
     }
     return true;
 }
 
 } // namespace
diff --git a/virtualkeyboard.cpp b/virtualkeyboard.cpp
index fd624f427..b1abe415c 100644
--- a/virtualkeyboard.cpp
+++ b/virtualkeyboard.cpp
@@ -1,502 +1,501 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtualkeyboard.h"
 #include "virtualkeyboard_dbus.h"
 #include "input.h"
 #include "keyboard_input.h"
 #include "utils.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xkb.h"
-#include "xdgshellclient.h"
 #include "screenlockerwatcher.h"
 
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/textinput_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 #include <KStatusNotifierItem>
 #include <KLocalizedString>
 
 #include <QDBusConnection>
 #include <QDBusPendingCall>
 #include <QDBusMessage>
 #include <QGuiApplication>
 #include <QQmlComponent>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQuickItem>
 #include <QQuickView>
 #include <QQuickWindow>
 #include <QTimer>
 // xkbcommon
 #include <xkbcommon/xkbcommon.h>
 
 using namespace KWayland::Server;
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(VirtualKeyboard)
 
 VirtualKeyboard::VirtualKeyboard(QObject *parent)
     : QObject(parent)
 {
     m_floodTimer = new QTimer(this);
     m_floodTimer->setSingleShot(true);
     m_floodTimer->setInterval(250);
     // this is actually too late. Other processes are started before init,
     // so might miss the availability of text input
     // but without Workspace we don't have the window listed at all
     connect(kwinApp(), &Application::workspaceCreated, this, &VirtualKeyboard::init);
 }
 
 VirtualKeyboard::~VirtualKeyboard() = default;
 
 void VirtualKeyboard::init()
 {
     // TODO: need a shared Qml engine
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Initializing window";
     m_inputWindow.reset(new QQuickView(nullptr));
     m_inputWindow->setFlags(Qt::FramelessWindowHint);
     m_inputWindow->setGeometry(screens()->geometry(screens()->current()));
     m_inputWindow->setResizeMode(QQuickView::SizeRootObjectToView);
     m_inputWindow->setSource(QUrl::fromLocalFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral(KWIN_NAME "/virtualkeyboard/main.qml"))));
     if (m_inputWindow->status() != QQuickView::Status::Ready) {
         qCWarning(KWIN_VIRTUALKEYBOARD) << "window not ready yet";
         m_inputWindow.reset();
         return;
     }
     m_inputWindow->setProperty("__kwin_input_method", true);
 
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::aboutToLock, this, &VirtualKeyboard::hide);
 
     if (waylandServer()) {
         m_enabled = !input()->hasAlphaNumericKeyboard();
         qCDebug(KWIN_VIRTUALKEYBOARD) << "enabled by default: " << m_enabled;
         connect(input(), &InputRedirection::hasAlphaNumericKeyboardChanged, this,
             [this] (bool set) {
                 qCDebug(KWIN_VIRTUALKEYBOARD) << "AlphaNumeric Keyboard changed:" << set << "toggling VirtualKeyboard.";
                 setEnabled(!set);
             }
         );
     }
 
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Registering the SNI";
     m_sni = new KStatusNotifierItem(QStringLiteral("kwin-virtual-keyboard"), this);
     m_sni->setStandardActionsEnabled(false);
     m_sni->setCategory(KStatusNotifierItem::Hardware);
     m_sni->setStatus(KStatusNotifierItem::Passive);
     m_sni->setTitle(i18n("Virtual Keyboard"));
     updateSni();
     connect(m_sni, &KStatusNotifierItem::activateRequested, this,
         [this] {
             setEnabled(!m_enabled);
         }
     );
     connect(this, &VirtualKeyboard::enabledChanged, this, &VirtualKeyboard::updateSni);
 
     auto dbus = new VirtualKeyboardDBus(this);
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Registering the DBus interface";
     dbus->setEnabled(m_enabled);
     connect(dbus, &VirtualKeyboardDBus::activateRequested, this, &VirtualKeyboard::setEnabled);
     connect(this, &VirtualKeyboard::enabledChanged, dbus, &VirtualKeyboardDBus::setEnabled);
 
     if (waylandServer()) {
         // we can announce support for the text input interface
         auto t = waylandServer()->display()->createTextInputManager(TextInputInterfaceVersion::UnstableV0, waylandServer()->display());
         t->create();
         auto t2 = waylandServer()->display()->createTextInputManager(TextInputInterfaceVersion::UnstableV2, waylandServer()->display());
         t2->create();
         connect(waylandServer()->seat(), &SeatInterface::focusedTextInputChanged, this,
             [this] {
                 disconnect(m_waylandShowConnection);
                 disconnect(m_waylandHideConnection);
                 disconnect(m_waylandHintsConnection);
                 disconnect(m_waylandSurroundingTextConnection);
                 disconnect(m_waylandResetConnection);
                 disconnect(m_waylandEnabledConnection);
                 qApp->inputMethod()->reset();
                 if (auto t = waylandServer()->seat()->focusedTextInput()) {
                     m_waylandShowConnection = connect(t, &TextInputInterface::requestShowInputPanel, this, &VirtualKeyboard::show);
                     m_waylandHideConnection = connect(t, &TextInputInterface::requestHideInputPanel, this, &VirtualKeyboard::hide);
                     m_waylandSurroundingTextConnection = connect(t, &TextInputInterface::surroundingTextChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImSurroundingText | Qt::ImCursorPosition | Qt::ImAnchorPosition);
                         }
                     );
                     m_waylandHintsConnection = connect(t, &TextInputInterface::contentTypeChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImHints);
                         }
                     );
                     m_waylandResetConnection = connect(t, &TextInputInterface::requestReset, qApp->inputMethod(), &QInputMethod::reset);
                     m_waylandEnabledConnection = connect(t, &TextInputInterface::enabledChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImQueryAll);
                         }
                     );
 
-                    auto newClient = waylandServer()->findAbstractClient(waylandServer()->seat()->focusedTextInputSurface());
+                    auto newClient = waylandServer()->findClient(waylandServer()->seat()->focusedTextInputSurface());
                     // Reset the old client virtual keybaord geom if necessary
                     // Old and new clients could be the same if focus moves between subsurfaces
                     if (newClient != m_trackedClient) {
                         if (m_trackedClient) {
                             m_trackedClient->setVirtualKeyboardGeometry(QRect());
                         }
                         m_trackedClient = newClient;
                     }
 
-                    m_trackedClient = waylandServer()->findAbstractClient(waylandServer()->seat()->focusedTextInputSurface());
+                    m_trackedClient = waylandServer()->findClient(waylandServer()->seat()->focusedTextInputSurface());
 
                     updateInputPanelState();
                 } else {
                     m_waylandShowConnection = QMetaObject::Connection();
                     m_waylandHideConnection = QMetaObject::Connection();
                     m_waylandHintsConnection = QMetaObject::Connection();
                     m_waylandSurroundingTextConnection = QMetaObject::Connection();
                     m_waylandResetConnection = QMetaObject::Connection();
                     m_waylandEnabledConnection = QMetaObject::Connection();
                 }
                 qApp->inputMethod()->update(Qt::ImQueryAll);
             }
         );
     }
     m_inputWindow->installEventFilter(this);
     connect(Workspace::self(), &Workspace::destroyed, this,
         [this] {
             m_inputWindow.reset();
         }
     );
     m_inputWindow->setColor(Qt::transparent);
     m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
     connect(m_inputWindow->rootObject(), &QQuickItem::childrenRectChanged, m_inputWindow.data(),
         [this] {
             if (!m_inputWindow) {
                 return;
             }
             m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
         }
     );
 
     connect(qApp->inputMethod(), &QInputMethod::visibleChanged, this, &VirtualKeyboard::updateInputPanelState);
 
     connect(m_inputWindow->rootObject(), &QQuickItem::childrenRectChanged, this, &VirtualKeyboard::updateInputPanelState);
 }
 
 void VirtualKeyboard::setEnabled(bool enabled)
 {
     if (m_enabled == enabled) {
         return;
     }
     m_enabled = enabled;
     qApp->inputMethod()->update(Qt::ImQueryAll);
     emit enabledChanged(m_enabled);
 
     // send OSD message
     QDBusMessage msg = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.plasmashell"),
         QStringLiteral("/org/kde/osdService"),
         QStringLiteral("org.kde.osdService"),
         QStringLiteral("virtualKeyboardEnabledChanged")
     );
     msg.setArguments({enabled});
     QDBusConnection::sessionBus().asyncCall(msg);
 }
 
 void VirtualKeyboard::updateSni()
 {
     if (!m_sni) {
         return;
     }
     if (m_enabled) {
         m_sni->setIconByName(QStringLiteral("input-keyboard-virtual-on"));
         m_sni->setTitle(i18n("Virtual Keyboard: enabled"));
     } else {
         m_sni->setIconByName(QStringLiteral("input-keyboard-virtual-off"));
         m_sni->setTitle(i18n("Virtual Keyboard: disabled"));
     }
     m_sni->setToolTipTitle(i18n("Whether to show the virtual keyboard on demand."));
 }
 
 void VirtualKeyboard::updateInputPanelState()
 {
     if (!waylandServer()) {
         return;
     }
 
     auto t = waylandServer()->seat()->focusedTextInput();
 
     if (!t || !m_inputWindow) {
         return;
     }
 
     const bool inputPanelHasBeenClosed = m_inputWindow->isVisible() && !qApp->inputMethod()->isVisible();
     if (inputPanelHasBeenClosed && m_floodTimer->isActive()) {
         return;
     }
     m_floodTimer->start();
 
     m_inputWindow->setVisible(qApp->inputMethod()->isVisible());
 
     if (qApp->inputMethod()->isVisible()) {
         m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
     }
 
     if (m_inputWindow->isVisible() && m_trackedClient && m_inputWindow->rootObject()) {
         const QRect inputPanelGeom = m_inputWindow->rootObject()->childrenRect().toRect().translated(m_inputWindow->geometry().topLeft());
 
         m_trackedClient->setVirtualKeyboardGeometry(inputPanelGeom);
 
         t->setInputPanelState(true, QRect(0, 0, 0, 0));
 
     } else {
         if (inputPanelHasBeenClosed && m_trackedClient) {
             m_trackedClient->setVirtualKeyboardGeometry(QRect());
         }
 
         t->setInputPanelState(false, QRect(0, 0, 0, 0));
     }
 }
 
 void VirtualKeyboard::show()
 {
     if (m_inputWindow.isNull() || !m_enabled) {
         return;
     }
     m_inputWindow->setGeometry(screens()->geometry(screens()->current()));
     qApp->inputMethod()->show();
 }
 
 void VirtualKeyboard::hide()
 {
     if (m_inputWindow.isNull()) {
         return;
     }
     m_inputWindow->hide();
     qApp->inputMethod()->hide();
 }
 
 bool VirtualKeyboard::event(QEvent *e)
 {
     if (e->type() == QEvent::InputMethod) {
         QInputMethodEvent *event = static_cast<QInputMethodEvent*>(e);
         if (m_enabled && waylandServer()) {
             bool isPreedit = false;
             for (auto attribute : event->attributes()) {
                 switch (attribute.type) {
                 case QInputMethodEvent::TextFormat:
                 case QInputMethodEvent::Cursor:
                 case QInputMethodEvent::Language:
                 case QInputMethodEvent::Ruby:
                     isPreedit = true;
                     break;
                 default:
                     break;
                 }
             }
             TextInputInterface *ti = waylandServer()->seat()->focusedTextInput();
             if (ti && ti->isEnabled()) {
                 if (!isPreedit && event->preeditString().isEmpty() && !event->commitString().isEmpty()) {
                     ti->commit(event->commitString().toUtf8());
                 } else {
                     ti->preEdit(event->preeditString().toUtf8(), event->commitString().toUtf8());
                 }
             }
         }
     }
     if (e->type() == QEvent::InputMethodQuery) {
         auto event = static_cast<QInputMethodQueryEvent*>(e);
         TextInputInterface *ti = nullptr;
         if (waylandServer() && m_enabled) {
             ti = waylandServer()->seat()->focusedTextInput();
         }
         if (event->queries().testFlag(Qt::ImEnabled)) {
             event->setValue(Qt::ImEnabled, QVariant(ti != nullptr && ti->isEnabled()));
         }
         if (event->queries().testFlag(Qt::ImCursorRectangle)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImFont)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImCursorPosition)) {
             // the virtual keyboard doesn't send us the cursor position in the preedit
             // this would break text input, thus we ignore it
             // see https://bugreports.qt.io/browse/QTBUG-53517
 #if 0
             event->setValue(Qt::ImCursorPosition, QString::fromUtf8(ti->surroundingText().left(ti->surroundingTextCursorPosition())).size());
 #else
             event->setValue(Qt::ImCursorPosition, 0);
 #endif
         }
         if (event->queries().testFlag(Qt::ImSurroundingText)) {
             // the virtual keyboard doesn't send us the cursor position in the preedit
             // this would break text input, thus we ignore it
             // see https://bugreports.qt.io/browse/QTBUG-53517
 #if 0
             event->setValue(Qt::ImSurroundingText, QString::fromUtf8(ti->surroundingText()));
 #else
             event->setValue(Qt::ImSurroundingText, QString());
 #endif
         }
         if (event->queries().testFlag(Qt::ImCurrentSelection)) {
             // TODO: should be text between cursor and anchor, but might be dangerous
         }
         if (event->queries().testFlag(Qt::ImMaximumTextLength)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImAnchorPosition)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImHints)) {
             if (ti && ti->isEnabled()) {
                 Qt::InputMethodHints hints;
                 const auto contentHints = ti->contentHints();
                 if (!contentHints.testFlag(TextInputInterface::ContentHint::AutoCompletion)) {
                     hints |= Qt::ImhNoPredictiveText;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::AutoCorrection)) {
                     // no mapping in Qt
                 }
                 if (!contentHints.testFlag(TextInputInterface::ContentHint::AutoCapitalization)) {
                     hints |= Qt::ImhNoAutoUppercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::LowerCase)) {
                     hints |= Qt::ImhPreferLowercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::UpperCase)) {
                     hints |= Qt::ImhPreferUppercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::TitleCase)) {
                     // no mapping in Qt
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::HiddenText)) {
                     hints |= Qt::ImhHiddenText;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::SensitiveData)) {
                     hints |= Qt::ImhSensitiveData;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::Latin)) {
                     hints |= Qt::ImhPreferLatin;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::MultiLine)) {
                     hints |= Qt::ImhMultiLine;
                 }
                 switch (ti->contentPurpose()) {
                 case TextInputInterface::ContentPurpose::Digits:
                     hints |= Qt::ImhDigitsOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Number:
                     hints |= Qt::ImhFormattedNumbersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Phone:
                     hints |= Qt::ImhDialableCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Url:
                     hints |= Qt::ImhUrlCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Email:
                     hints |= Qt::ImhEmailCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Date:
                     hints |= Qt::ImhDate;
                     break;
                 case TextInputInterface::ContentPurpose::Time:
                     hints |= Qt::ImhTime;
                     break;
                 case TextInputInterface::ContentPurpose::DateTime:
                     hints |= Qt::ImhDate;
                     hints |= Qt::ImhTime;
                     break;
                 case TextInputInterface::ContentPurpose::Name:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Password:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Terminal:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Normal:
                     // that's the default
                 case TextInputInterface::ContentPurpose::Alpha:
                     // no mapping in Qt
                     break;
                 }
                 event->setValue(Qt::ImHints, QVariant(int(hints)));
             } else {
                 event->setValue(Qt::ImHints, Qt::ImhNone);
             }
         }
         if (event->queries().testFlag(Qt::ImPreferredLanguage)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImPlatformData)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImAbsolutePosition)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImTextBeforeCursor)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImTextAfterCursor)) {
             // not used by virtual keyboard
         }
         event->accept();
         return true;
     }
     return QObject::event(e);
 }
 
 bool VirtualKeyboard::eventFilter(QObject *o, QEvent *e)
 {
     if (o != m_inputWindow.data() || !m_inputWindow->isVisible()) {
         return false;
     }
     if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
         QKeyEvent *event = static_cast<QKeyEvent*>(e);
         if (event->nativeScanCode() == 0) {
             // this is a key composed by the virtual keyboard - we need to send it to the client
             const auto sym = input()->keyboard()->xkb()->fromKeyEvent(event);
             if (sym != 0) {
                 if (waylandServer()) {
                     auto t = waylandServer()->seat()->focusedTextInput();
                     if (t && t->isEnabled()) {
                         if (e->type() == QEvent::KeyPress) {
                             t->keysymPressed(sym);
                         } else if (e->type() == QEvent::KeyRelease) {
                             t->keysymReleased(sym);
                         }
                     }
                 }
             }
             return true;
         }
     }
     return false;
 }
 
 QWindow *VirtualKeyboard::inputPanel() const
 {
     return m_inputWindow.data();
 }
 
 }
diff --git a/wayland_server.cpp b/wayland_server.cpp
index c2f282e33..0e284c511 100644
--- a/wayland_server.cpp
+++ b/wayland_server.cpp
@@ -1,790 +1,790 @@
 /********************************************************************
  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 "x11client.h"
 #include "platform.h"
 #include "composite.h"
 #include "idle_inhibition.h"
 #include "screens.h"
 #include "xdgshellclient.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/compositor.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/datadevicemanager.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/linuxdmabuf_v1_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/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>
 #include <KWayland/Server/keystate_interface.h>
 #include <KWayland/Server/filtered_display.h>
 
 // KF
 #include <KServiceTypeTrader>
 
 // Qt
 #include <QCryptographicHash>
 #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>();
 }
 
 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.compositor;
         delete m_internalConnection.seat;
         delete m_internalConnection.ddm;
         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();
     }
     XdgShellClient *client = new XdgShellClient(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);
     }
     m_clients << client;
     if (client->readyForPainting()) {
         emit shellClientAdded(client);
     } else {
         connect(client, &XdgShellClient::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);
     });
 }
 
 class KWinDisplay : public KWayland::Server::FilteredDisplay
 {
 public:
     KWinDisplay(QObject *parent)
         : KWayland::Server::FilteredDisplay(parent)
     {}
 
     static QByteArray sha256(const QString &fileName)
     {
         QFile f(fileName);
         if (f.open(QFile::ReadOnly)) {
             QCryptographicHash hash(QCryptographicHash::Sha256);
             if (hash.addData(&f)) {
                 return hash.result();
             }
         }
         return QByteArray();
     }
 
     bool isTrustedOrigin(KWayland::Server::ClientConnection *client) const {
         const auto fullPathSha = sha256(client->executablePath());
         const auto localSha = sha256(QLatin1String("/proc/") + QString::number(client->processId()) + QLatin1String("/exe"));
         const bool trusted = !localSha.isEmpty() && fullPathSha == localSha;
 
         if (!trusted) {
             qCWarning(KWIN_CORE) << "Could not trust" << client->executablePath() << "sha" << localSha << fullPathSha;
         }
 
         return trusted;
     }
 
     QStringList fetchRequestedInterfaces(KWayland::Server::ClientConnection *client) const {
         const auto serviceQuery = QStringLiteral("exist Exec and exist [X-KDE-Wayland-Interfaces] and '%1' =~ Exec").arg(client->executablePath());
         const auto servicesFound = KServiceTypeTrader::self()->query(QStringLiteral("Application"), serviceQuery);
 
         if (servicesFound.isEmpty()) {
             qCDebug(KWIN_CORE) << "Could not find the desktop file for" << client->executablePath();
             return {};
         }
 
         const auto interfaces = servicesFound.first()->property("X-KDE-Wayland-Interfaces").toStringList();
         qCDebug(KWIN_CORE) << "Interfaces for" << client->executablePath() << interfaces;
         return interfaces;
     }
 
     QSet<QByteArray> interfacesBlackList = {"org_kde_kwin_remote_access_manager", "org_kde_plasma_window_management", "org_kde_kwin_fake_input", "org_kde_kwin_keystate"};
 
     bool allowInterface(KWayland::Server::ClientConnection *client, const QByteArray &interfaceName) override {
         if (client->processId() == getpid()) {
             return true;
         }
 
         if (!interfacesBlackList.contains(interfaceName)) {
             return true;
         }
 
         if (client->executablePath().isEmpty()) {
             qCWarning(KWIN_CORE) << "Could not identify process with pid" << client->processId();
             return false;
         }
 
         {
             auto requestedInterfaces = client->property("requestedInterfaces");
             if (requestedInterfaces.isNull()) {
                 requestedInterfaces = fetchRequestedInterfaces(client);
                 client->setProperty("requestedInterfaces", requestedInterfaces);
             }
             if (!requestedInterfaces.toStringList().contains(QString::fromUtf8(interfaceName))) {
                 qCWarning(KWIN_CORE) << "Did not grant the interface" << interfaceName << "to" << client->executablePath() << ". Please request it under X-KDE-Wayland-Interfaces";
                 return false;
             }
         }
 
         {
             auto trustedOrigin = client->property("isPrivileged");
             if (trustedOrigin.isNull()) {
                 trustedOrigin = isTrustedOrigin(client);
                 client->setProperty("isPrivileged", trustedOrigin);
             }
 
             if (!trustedOrigin.toBool()) {
                 return false;
             }
         }
         qCDebug(KWIN_CORE) << "authorized" << client->executablePath() << interfaceName;
         return true;
     }
 };
 
 bool WaylandServer::init(const QByteArray &socketName, InitalizationFlags flags)
 {
     m_initFlags = flags;
     m_display = new KWinDisplay(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_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 (XdgShellClient *client = findClient(deco->surface()->surface())) {
+        if (XdgShellClient *client = findXdgShellClient(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();
     m_dataDeviceManager = m_display->createDataDeviceManager(m_display);
     m_dataDeviceManager->create();
     m_idle = m_display->createIdle(m_display);
     m_idle->create();
     auto idleInhibition = new IdleInhibition(m_idle);
-    connect(this, &WaylandServer::shellClientAdded, idleInhibition, &IdleInhibition::registerXdgShellClient);
+    connect(this, &WaylandServer::shellClientAdded, idleInhibition, &IdleInhibition::registerClient);
     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 (XdgShellClient *client = findClient(surface->surface())) {
+            if (XdgShellClient *client = findXdgShellClient(surface->surface())) {
                 client->installPlasmaShellSurface(surface);
             } else {
                 m_plasmaShellSurfaces << surface;
                 connect(surface, &QObject::destroyed, this,
                     [this, surface] {
                         m_plasmaShellSurfaces.removeOne(surface);
                     }
                 );
             }
         }
     );
     m_appMenuManager = m_display->createAppMenuManagerInterface(m_display);
     m_appMenuManager->create();
     connect(m_appMenuManager, &AppMenuManagerInterface::appMenuCreated,
         [this] (AppMenuInterface *appMenu) {
-            if (XdgShellClient *client = findClient(appMenu->surface())) {
+            if (XdgShellClient *client = findXdgShellClient(appMenu->surface())) {
                 client->installAppMenu(appMenu);
             }
         }
     );
     m_paletteManager = m_display->createServerSideDecorationPaletteManager(m_display);
     m_paletteManager->create();
     connect(m_paletteManager, &ServerSideDecorationPaletteManagerInterface::paletteCreated,
         [this] (ServerSideDecorationPaletteInterface *palette) {
-            if (XdgShellClient *client = findClient(palette->surface())) {
+            if (XdgShellClient *client = findXdgShellClient(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 (XdgShellClient *c = findClient(deco->surface())) {
+            if (XdgShellClient *c = findXdgShellClient(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()->requestOutputsChange(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();
 
     m_keyState = m_display->createKeyStateInterface(m_display);
     m_keyState->create();
 
     return true;
 }
 
 KWayland::Server::LinuxDmabufUnstableV1Interface *WaylandServer::linuxDmabuf()
 {
     if (!m_linuxDmabuf) {
         m_linuxDmabuf = m_display->createLinuxDmabufInterface(m_display);
         m_linuxDmabuf->create();
     }
     return m_linuxDmabuf;
 }
 
 SurfaceInterface *WaylandServer::findForeignTransientForSurface(SurfaceInterface *surface)
 {
     return m_XdgForeign->transientFor(surface);
 }
 
 void WaylandServer::shellClientShown(Toplevel *t)
 {
     XdgShellClient *c = dynamic_cast<XdgShellClient *>(t);
     if (!c) {
         qCWarning(KWIN_CORE) << "Failed to cast a Toplevel which is supposed to be a XdgShellClient to XdgShellClient";
         return;
     }
     disconnect(c, &XdgShellClient::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();
 }
 
 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;
     }
     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;
 }
 
 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, registry] {
                     m_internalConnection.interfacesAnnounced = true;
 
                     const auto compInterface = registry->interface(Registry::Interface::Compositor);
                     if (compInterface.name != 0) {
                         m_internalConnection.compositor = registry->createCompositor(compInterface.name, compInterface.version, this);
                     }
                     const auto seatInterface = registry->interface(Registry::Interface::Seat);
                     if (seatInterface.name != 0) {
                         m_internalConnection.seat = registry->createSeat(seatInterface.name, seatInterface.version, this);
                     }
                     const auto ddmInterface = registry->interface(Registry::Interface::DataDeviceManager);
                     if (ddmInterface.name != 0) {
                         m_internalConnection.ddm = registry->createDataDeviceManager(ddmInterface.name, ddmInterface.version, this);
                     }
                 }
             );
             registry->setup();
         }
     );
     m_internalConnection.client->initConnection();
 }
 
-void WaylandServer::removeClient(XdgShellClient *c)
+void WaylandServer::removeClient(AbstractClient *c)
 {
     m_clients.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 XdgShellClient *findClientInList(const QList<XdgShellClient *> &clients, quint32 id)
+static AbstractClient *findClientInList(const QList<AbstractClient *> &clients, quint32 id)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
-        [id] (XdgShellClient *c) {
+        [id] (AbstractClient *c) {
             return c->windowId() == id;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
-static XdgShellClient *findClientInList(const QList<XdgShellClient *> &clients, KWayland::Server::SurfaceInterface *surface)
+static AbstractClient *findClientInList(const QList<AbstractClient *> &clients, KWayland::Server::SurfaceInterface *surface)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
-        [surface] (XdgShellClient *c) {
+        [surface] (AbstractClient *c) {
             return c->surface() == surface;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
-XdgShellClient *WaylandServer::findClient(quint32 id) const
+AbstractClient *WaylandServer::findClient(quint32 id) const
 {
     if (id == 0) {
         return nullptr;
     }
-    if (XdgShellClient *c = findClientInList(m_clients, id)) {
+    if (AbstractClient *c = findClientInList(m_clients, id)) {
         return c;
     }
     return nullptr;
 }
 
-XdgShellClient *WaylandServer::findClient(SurfaceInterface *surface) const
+AbstractClient *WaylandServer::findClient(SurfaceInterface *surface) const
 {
     if (!surface) {
         return nullptr;
     }
-    if (XdgShellClient *c = findClientInList(m_clients, surface)) {
+    if (AbstractClient *c = findClientInList(m_clients, surface)) {
         return c;
     }
     return nullptr;
 }
 
-AbstractClient *WaylandServer::findAbstractClient(SurfaceInterface *surface) const
+XdgShellClient *WaylandServer::findXdgShellClient(SurfaceInterface *surface) const
 {
-    return findClient(surface);
+    return qobject_cast<XdgShellClient *>(findClient(surface));
 }
 
 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();
     }
 }
 
 void WaylandServer::updateKeyState(KWin::Xkb::LEDs leds)
 {
     if (!m_keyState)
         return;
 
     m_keyState->setState(KeyStateInterface::Key::CapsLock, leds & KWin::Xkb::LED::CapsLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
     m_keyState->setState(KeyStateInterface::Key::NumLock, leds & KWin::Xkb::LED::NumLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
     m_keyState->setState(KeyStateInterface::Key::ScrollLock, leds & KWin::Xkb::LED::ScrollLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
 }
 
 }
diff --git a/wayland_server.h b/wayland_server.h
index 6ff825916..ebb5c3e18 100644
--- a/wayland_server.h
+++ b/wayland_server.h
@@ -1,299 +1,299 @@
 /********************************************************************
  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 "keyboard_input.h"
 
 #include <QObject>
 
 class QThread;
 class QProcess;
 class QWindow;
 
 namespace KWayland
 {
 namespace Client
 {
 class ConnectionThread;
 class Registry;
 class Compositor;
 class Seat;
 class DataDeviceManager;
 class ShmPool;
 class Surface;
 }
 namespace Server
 {
 class AppMenuManagerInterface;
 class ClientConnection;
 class CompositorInterface;
 class Display;
 class DataDeviceInterface;
 class IdleInterface;
 class SeatInterface;
 class DataDeviceManagerInterface;
 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;
 class KeyStateInterface;
 class LinuxDmabufUnstableV1Interface;
 class LinuxDmabufUnstableV1Buffer;
 }
 }
 
 namespace KWin
 {
 class XdgShellClient;
 
 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)
 
     ~WaylandServer() override;
     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::DataDeviceManagerInterface *dataDeviceManager() {
         return m_dataDeviceManager;
     }
     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;
     }
     KWayland::Server::LinuxDmabufUnstableV1Interface *linuxDmabuf();
 
-    QList<XdgShellClient *> clients() const {
+    QList<AbstractClient *> clients() const {
         return m_clients;
     }
-    void removeClient(XdgShellClient *c);
-    XdgShellClient *findClient(quint32 id) const;
-    XdgShellClient *findClient(KWayland::Server::SurfaceInterface *surface) const;
-    AbstractClient *findAbstractClient(KWayland::Server::SurfaceInterface *surface) const;
+    void removeClient(AbstractClient *c);
+    AbstractClient *findClient(quint32 id) const;
+    AbstractClient *findClient(KWayland::Server::SurfaceInterface *surface) const;
+    XdgShellClient *findXdgShellClient(KWayland::Server::SurfaceInterface *surface) const;
 
     /**
      * @returns 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();
 
     /**
      * @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;
     }
     KWayland::Client::Compositor *internalCompositor() {
         return m_internalConnection.compositor;
     }
     KWayland::Client::Seat *internalSeat() {
         return m_internalConnection.seat;
     }
     KWayland::Client::DataDeviceManager *internalDataDeviceManager() {
         return m_internalConnection.ddm;
     }
     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();
     void updateKeyState(KWin::Xkb::LEDs leds);
 
     QSet<KWayland::Server::LinuxDmabufUnstableV1Buffer*> linuxDmabufBuffers() const {
         return m_linuxDmabufBuffers;
     }
     void addLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers << buffer;
     }
     void removeLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers.remove(buffer);
     }
 
 Q_SIGNALS:
-    void shellClientAdded(KWin::XdgShellClient *);
-    void shellClientRemoved(KWin::XdgShellClient *);
+    void shellClientAdded(KWin::AbstractClient *);
+    void shellClientRemoved(KWin::AbstractClient *);
     void terminatingInternalClientConnection();
     void initialized();
     void foreignTransientChanged(KWayland::Server::SurfaceInterface *child);
 
 private:
     void shellClientShown(Toplevel *t);
     quint16 createClientId(KWayland::Server::ClientConnection *c);
     void destroyInternalConnection();
     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::DataDeviceManagerInterface *m_dataDeviceManager = 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::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;
     KWayland::Server::LinuxDmabufUnstableV1Interface *m_linuxDmabuf = nullptr;
     QSet<KWayland::Server::LinuxDmabufUnstableV1Buffer*> m_linuxDmabufBuffers;
     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::Compositor *compositor = nullptr;
         KWayland::Client::Seat *seat = nullptr;
         KWayland::Client::DataDeviceManager *ddm = nullptr;
         KWayland::Client::ShmPool *shm = nullptr;
         bool interfacesAnnounced = false;
 
     } m_internalConnection;
     KWayland::Server::XdgForeignInterface *m_XdgForeign = nullptr;
     KWayland::Server::KeyStateInterface *m_keyState = nullptr;
-    QList<XdgShellClient *> m_clients;
+    QList<AbstractClient *> m_clients;
     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
 
diff --git a/workspace.cpp b/workspace.cpp
index 21f9a11f6..9f25bb215 100644
--- a/workspace.cpp
+++ b/workspace.cpp
@@ -1,2781 +1,2784 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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/>.
 *********************************************************************/
 // own
 #include "workspace.h"
 // kwin libs
 #include <kwinglplatform.h>
 // kwin
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "appmenu.h"
 #include "atoms.h"
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "dbusinterface.h"
 #include "deleted.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "group.h"
 #include "input.h"
 #include "internal_client.h"
 #include "logind.h"
 #include "moving_client_x11_filter.h"
 #include "killwindow.h"
 #include "netinfo.h"
 #include "outline.h"
 #include "placement.h"
 #include "rules.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "platform.h"
 #include "scripting/scripting.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "unmanaged.h"
 #include "useractions.h"
 #include "virtualdesktops.h"
 #include "xdgshellclient.h"
 #include "was_user_interaction_x11_filter.h"
 #include "wayland_server.h"
 #include "xcbutils.h"
 #include "main.h"
 #include "decorations/decorationbridge.h"
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KStartupInfo>
 // Qt
 #include <QtConcurrentRun>
 
 namespace KWin
 {
 
 extern int screen_number;
 extern bool is_multihead;
 
 ColorMapper::ColorMapper(QObject *parent)
     : QObject(parent)
     , m_default(defaultScreen()->default_colormap)
     , m_installed(defaultScreen()->default_colormap)
 {
 }
 
 ColorMapper::~ColorMapper()
 {
 }
 
 void ColorMapper::update()
 {
     xcb_colormap_t cmap = m_default;
     if (X11Client *c = dynamic_cast<X11Client *>(Workspace::self()->activeClient())) {
         if (c->colormap() != XCB_COLORMAP_NONE) {
             cmap = c->colormap();
         }
     }
     if (cmap != m_installed) {
         xcb_install_colormap(connection(), cmap);
         m_installed = cmap;
     }
 }
 
 Workspace* Workspace::_self = nullptr;
 
 Workspace::Workspace(const QString &sessionKey)
     : QObject(nullptr)
     , m_compositor(nullptr)
     // Unsorted
     , active_popup(nullptr)
     , active_popup_client(nullptr)
     , m_initialDesktop(1)
     , active_client(nullptr)
     , last_active_client(nullptr)
     , most_recently_raised(nullptr)
     , movingClient(nullptr)
     , delayfocus_client(nullptr)
     , force_restacking(false)
     , showing_desktop(false)
     , was_user_interaction(false)
     , block_focus(0)
     , m_userActionsMenu(new UserActionsMenu(this))
     , client_keys_dialog(nullptr)
     , client_keys_client(nullptr)
     , global_shortcuts_disabled_for_client(false)
     , workspaceInit(true)
     , startup(nullptr)
     , set_active_client_recursion(0)
     , block_stacking_updates(0)
     , m_sessionManager(new SessionManager(this))
 {
     // If KWin was already running it saved its configuration after loosing the selection -> Reread
     QFuture<void> reparseConfigFuture = QtConcurrent::run(options, &Options::reparseConfiguration);
 
     ApplicationMenu::create(this);
 
     _self = this;
 
 #ifdef KWIN_BUILD_ACTIVITIES
     Activities *activities = nullptr;
     if (kwinApp()->usesKActivities()) {
         activities = Activities::create(this);
     }
     if (activities) {
         connect(activities, SIGNAL(currentChanged(QString)), SLOT(updateCurrentActivity(QString)));
     }
 #endif
 
     // PluginMgr needs access to the config file, so we need to wait for it for finishing
     reparseConfigFuture.waitForFinished();
 
     options->loadConfig();
     options->loadCompositingConfig(false);
 
     delayFocusTimer = nullptr;
 
     if (!sessionKey.isEmpty())
         loadSessionInfo(sessionKey);
     connect(qApp, &QGuiApplication::saveStateRequest, this, &Workspace::saveState);
 
     RuleBook::create(this)->load();
 
     ScreenEdges::create(this);
 
     // VirtualDesktopManager needs to be created prior to init shortcuts
     // and prior to TabBox, due to TabBox connecting to signals
     // actual initialization happens in init()
     VirtualDesktopManager::create(this);
     //dbus interface
     new VirtualDesktopManagerDBusInterface(VirtualDesktopManager::self());
 
 #ifdef KWIN_BUILD_TABBOX
     // need to create the tabbox before compositing scene is setup
     TabBox::TabBox::create(this);
 #endif
 
     if (Compositor::self()) {
         m_compositor = Compositor::self();
     } else {
         Q_ASSERT(kwinApp()->operationMode() == Application::OperationMode::OperationModeX11);
         m_compositor = X11Compositor::create(this);
     }
     connect(this, &Workspace::currentDesktopChanged, m_compositor, &Compositor::addRepaintFull);
     connect(m_compositor, &QObject::destroyed, this, [this] { m_compositor = nullptr; });
 
     auto decorationBridge = Decoration::DecorationBridge::create(this);
     decorationBridge->init();
     connect(this, &Workspace::configChanged, decorationBridge, &Decoration::DecorationBridge::reconfigure);
 
     new DBusInterface(this);
 
     Outline::create(this);
 
     initShortcuts();
 
     init();
 }
 
 void Workspace::init()
 {
     KSharedConfigPtr config = kwinApp()->config();
     kwinApp()->createScreens();
     Screens *screens = Screens::self();
     // get screen support
     connect(screens, SIGNAL(changed()), SLOT(desktopResized()));
     screens->setConfig(config);
     screens->reconfigure();
     connect(options, SIGNAL(configChanged()), screens, SLOT(reconfigure()));
     ScreenEdges *screenEdges = ScreenEdges::self();
     screenEdges->setConfig(config);
     screenEdges->init();
     connect(options, SIGNAL(configChanged()), screenEdges, SLOT(reconfigure()));
     connect(VirtualDesktopManager::self(), SIGNAL(layoutChanged(int,int)), screenEdges, SLOT(updateLayout()));
     connect(this, &Workspace::clientActivated, screenEdges, &ScreenEdges::checkBlocking);
 
     FocusChain *focusChain = FocusChain::create(this);
     connect(this, &Workspace::clientRemoved, focusChain, &FocusChain::remove);
     connect(this, &Workspace::clientActivated, focusChain, &FocusChain::setActiveClient);
     connect(VirtualDesktopManager::self(), SIGNAL(countChanged(uint,uint)), focusChain, SLOT(resize(uint,uint)));
     connect(VirtualDesktopManager::self(), SIGNAL(currentChanged(uint,uint)), focusChain, SLOT(setCurrentDesktop(uint,uint)));
     connect(options, SIGNAL(separateScreenFocusChanged(bool)), focusChain, SLOT(setSeparateScreenFocus(bool)));
     focusChain->setSeparateScreenFocus(options->isSeparateScreenFocus());
 
     // create VirtualDesktopManager and perform dependency injection
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(vds, &VirtualDesktopManager::desktopRemoved, this,
         [this](KWin::VirtualDesktop *desktop) {
             //Wayland
             if (kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
                 kwinApp()->operationMode() == Application::OperationModeXwayland) {
                 for (auto it = m_allClients.constBegin(); it != m_allClients.constEnd(); ++it) {
                     if (!(*it)->desktops().contains(desktop)) {
                         continue;
                     }
                     if ((*it)->desktops().count() > 1) {
                         (*it)->leaveDesktop(desktop);
                     } else {
                         sendClientToDesktop(*it, qMin(desktop->x11DesktopNumber(), VirtualDesktopManager::self()->count()), true);
                     }
                 }
             //X11
             } else {
                 for (auto it = m_allClients.constBegin(); it != m_allClients.constEnd(); ++it) {
                     if (!(*it)->isOnAllDesktops() && ((*it)->desktop() > static_cast<int>(VirtualDesktopManager::self()->count()))) {
                         sendClientToDesktop(*it, VirtualDesktopManager::self()->count(), true);
                     }
                 }
             }
         }
     );
 
     connect(vds, SIGNAL(countChanged(uint,uint)), SLOT(slotDesktopCountChanged(uint,uint)));
     connect(vds, SIGNAL(currentChanged(uint,uint)), SLOT(slotCurrentDesktopChanged(uint,uint)));
     vds->setNavigationWrappingAround(options->isRollOverDesktops());
     connect(options, SIGNAL(rollOverDesktopsChanged(bool)), vds, SLOT(setNavigationWrappingAround(bool)));
     vds->setConfig(config);
 
     // Now we know how many desktops we'll have, thus we initialize the positioning object
     Placement::create(this);
 
     // positioning object needs to be created before the virtual desktops are loaded.
     vds->load();
     vds->updateLayout();
     //makes sure any autogenerated id is saved, necessary as in case of xwayland, load will be called 2 times
     // load is needed to be called again when starting xwayalnd to sync to RootInfo, see BUG 385260
     vds->save();
 
     if (!VirtualDesktopManager::self()->setCurrent(m_initialDesktop))
         VirtualDesktopManager::self()->setCurrent(1);
 
     reconfigureTimer.setSingleShot(true);
     updateToolWindowsTimer.setSingleShot(true);
 
     connect(&reconfigureTimer, SIGNAL(timeout()), this, SLOT(slotReconfigure()));
     connect(&updateToolWindowsTimer, SIGNAL(timeout()), this, SLOT(slotUpdateToolWindows()));
 
     // TODO: do we really need to reconfigure everything when fonts change?
     // maybe just reconfigure the decorations? Move this into libkdecoration?
     QDBusConnection::sessionBus().connect(QString(),
                                           QStringLiteral("/KDEPlatformTheme"),
                                           QStringLiteral("org.kde.KDEPlatformTheme"),
                                           QStringLiteral("refreshFonts"),
                                           this, SLOT(reconfigure()));
 
     active_client = nullptr;
 
     initWithX11();
 
     Scripting::create(this);
 
-    if (auto w = waylandServer()) {
-        connect(w, &WaylandServer::shellClientAdded, this,
-            [this] (XdgShellClient *c) {
-                setupClientConnections(c);
-                c->updateDecoration(false);
-                updateClientLayer(c);
-                if (!c->isInternal()) {
-                    const QRect area = clientArea(PlacementArea, Screens::self()->current(), c->desktop());
-                    bool placementDone = false;
-                    if (c->isInitialPositionSet()) {
-                        placementDone = true;
-                    }
-                    if (c->isFullScreen()) {
-                        placementDone = true;
-                    }
-                    if (c->maximizeMode() == MaximizeMode::MaximizeFull) {
-                        placementDone = true;
-                    }
-                    if (c->rules()->checkPosition(invalidPoint, true) != invalidPoint) {
-                        placementDone = true;
-                    }
-                    if (!placementDone) {
-                        c->placeIn(area);
-                    }
-                    m_allClients.append(c);
-                    if (!unconstrained_stacking_order.contains(c))
-                        unconstrained_stacking_order.append(c);   // Raise if it hasn't got any stacking position yet
-                    if (!stacking_order.contains(c))    // It'll be updated later, and updateToolWindows() requires
-                        stacking_order.append(c);      // c to be in stacking_order
-                }
-                markXStackingOrderAsDirty();
-                updateStackingOrder(true);
-                updateClientArea();
-                if (c->wantsInput() && !c->isMinimized()) {
-                    activateClient(c);
-                }
-                updateTabbox();
-                connect(c, &XdgShellClient::windowShown, this,
-                    [this, c] {
-                        updateClientLayer(c);
-                        // TODO: when else should we send the client through placement?
-                        if (c->hasTransientPlacementHint()) {
-                            const QRect area = clientArea(PlacementArea, Screens::self()->current(), c->desktop());
-                            c->placeIn(area);
-                        }
-                        markXStackingOrderAsDirty();
-                        updateStackingOrder(true);
-                        updateClientArea();
-                        if (c->wantsInput()) {
-                            activateClient(c);
-                        }
-                    }
-                );
-                connect(c, &XdgShellClient::windowHidden, this,
-                    [this] {
-                        // TODO: update tabbox if it's displayed
-                        markXStackingOrderAsDirty();
-                        updateStackingOrder(true);
-                        updateClientArea();
-                    }
-                );
-            }
-        );
-        connect(w, &WaylandServer::shellClientRemoved, this,
-            [this] (XdgShellClient *c) {
-                m_allClients.removeAll(c);
-                if (c == most_recently_raised) {
-                    most_recently_raised = nullptr;
-                }
-                if (c == delayfocus_client) {
-                    cancelDelayFocus();
-                }
-                if (c == last_active_client) {
-                    last_active_client = nullptr;
-                }
-                if (client_keys_client == c) {
-                    setupWindowShortcutDone(false);
-                }
-                if (!c->shortcut().isEmpty()) {
-                    c->setShortcut(QString());   // Remove from client_keys
-                }
-                clientHidden(c);
-                emit clientRemoved(c);
-                markXStackingOrderAsDirty();
-                updateStackingOrder(true);
-                updateClientArea();
-                updateTabbox();
-            }
-        );
+    if (auto server = waylandServer()) {
+        connect(server, &WaylandServer::shellClientAdded, this, &Workspace::addShellClient);
+        connect(server, &WaylandServer::shellClientRemoved, this, &Workspace::removeShellClient);
     }
 
     // SELI TODO: This won't work with unreasonable focus policies,
     // and maybe in rare cases also if the selected client doesn't
     // want focus
     workspaceInit = false;
 
     // broadcast that Workspace is ready, but first process all events.
     QMetaObject::invokeMethod(this, "workspaceInitialized", Qt::QueuedConnection);
 
     // TODO: ungrabXServer()
 }
 
 void Workspace::initWithX11()
 {
     if (!kwinApp()->x11Connection()) {
         connect(kwinApp(), &Application::x11ConnectionChanged, this, &Workspace::initWithX11, Qt::UniqueConnection);
         return;
     }
     disconnect(kwinApp(), &Application::x11ConnectionChanged, this, &Workspace::initWithX11);
 
     atoms->retrieveHelpers();
 
     // first initialize the extensions
     Xcb::Extensions::self();
     ColorMapper *colormaps = new ColorMapper(this);
     connect(this, &Workspace::clientActivated, colormaps, &ColorMapper::update);
 
     // Call this before XSelectInput() on the root window
     startup = new KStartupInfo(
         KStartupInfo::DisableKWinModule | KStartupInfo::AnnounceSilenceChanges, this);
 
     // Select windowmanager privileges
     selectWmInputEventMask();
 
     // Compatibility
     int32_t data = 1;
 
     xcb_change_property(connection(), XCB_PROP_MODE_APPEND, rootWindow(), atoms->kwin_running,
                         atoms->kwin_running, 32, 1, &data);
 
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         m_wasUserInteractionFilter.reset(new WasUserInteractionX11Filter);
         m_movingClientFilter.reset(new MovingClientX11Filter);
     }
     updateXTime(); // Needed for proper initialization of user_time in Client ctor
 
     const uint32_t nullFocusValues[] = {true};
     m_nullFocus.reset(new Xcb::Window(QRect(-1, -1, 1, 1), XCB_WINDOW_CLASS_INPUT_ONLY, XCB_CW_OVERRIDE_REDIRECT, nullFocusValues));
     m_nullFocus->map();
 
     RootInfo *rootInfo = RootInfo::create();
     const auto vds = VirtualDesktopManager::self();
     vds->setRootInfo(rootInfo);
     // load again to sync to RootInfo, see BUG 385260
     vds->load();
     vds->updateRootInfo();
     rootInfo->setCurrentDesktop(vds->currentDesktop()->x11DesktopNumber());
 
     // TODO: only in X11 mode
     // Extra NETRootInfo instance in Client mode is needed to get the values of the properties
     NETRootInfo client_info(connection(), NET::ActiveWindow | NET::CurrentDesktop);
     if (!qApp->isSessionRestored()) {
         m_initialDesktop = client_info.currentDesktop();
         vds->setCurrent(m_initialDesktop);
     }
 
     // TODO: better value
     rootInfo->setActiveWindow(None);
     focusToNull();
 
     if (!qApp->isSessionRestored())
         ++block_focus; // Because it will be set below
 
     {
         // Begin updates blocker block
         StackingUpdatesBlocker blocker(this);
 
         Xcb::Tree tree(rootWindow());
         xcb_window_t *wins = xcb_query_tree_children(tree.data());
 
         QVector<Xcb::WindowAttributes> windowAttributes(tree->children_len);
         QVector<Xcb::WindowGeometry> windowGeometries(tree->children_len);
 
         // Request the attributes and geometries of all toplevel windows
         for (int i = 0; i < tree->children_len; i++) {
             windowAttributes[i] = Xcb::WindowAttributes(wins[i]);
             windowGeometries[i] = Xcb::WindowGeometry(wins[i]);
         }
 
         // Get the replies
         for (int i = 0; i < tree->children_len; i++) {
             Xcb::WindowAttributes attr(windowAttributes.at(i));
 
             if (attr.isNull()) {
                 continue;
             }
 
             if (attr->override_redirect) {
                 if (attr->map_state == XCB_MAP_STATE_VIEWABLE &&
                     attr->_class != XCB_WINDOW_CLASS_INPUT_ONLY)
                     // ### This will request the attributes again
                     createUnmanaged(wins[i]);
             } else if (attr->map_state != XCB_MAP_STATE_UNMAPPED) {
                 if (Application::wasCrash()) {
                     fixPositionAfterCrash(wins[i], windowGeometries.at(i).data());
                 }
 
                 // ### This will request the attributes again
                 createClient(wins[i], true);
             }
         }
 
         // Propagate clients, will really happen at the end of the updates blocker block
         updateStackingOrder(true);
 
         saveOldScreenSizes();
         updateClientArea();
 
         // NETWM spec says we have to set it to (0,0) if we don't support it
         NETPoint* viewports = new NETPoint[VirtualDesktopManager::self()->count()];
         rootInfo->setDesktopViewport(VirtualDesktopManager::self()->count(), *viewports);
         delete[] viewports;
         QRect geom;
         for (int i = 0; i < screens()->count(); i++) {
             geom |= screens()->geometry(i);
         }
         NETSize desktop_geometry;
         desktop_geometry.width = geom.width();
         desktop_geometry.height = geom.height();
         rootInfo->setDesktopGeometry(desktop_geometry);
         setShowingDesktop(false);
 
     } // End updates blocker block
 
     // TODO: only on X11?
     AbstractClient* new_active_client = nullptr;
     if (!qApp->isSessionRestored()) {
         --block_focus;
         new_active_client = findClient(Predicate::WindowMatch, client_info.activeWindow());
     }
     if (new_active_client == nullptr
             && activeClient() == nullptr && should_get_focus.count() == 0) {
         // No client activated in manage()
         if (new_active_client == nullptr)
             new_active_client = topClientOnDesktop(VirtualDesktopManager::self()->current(), -1);
         if (new_active_client == nullptr && !desktops.isEmpty())
             new_active_client = findDesktop(true, VirtualDesktopManager::self()->current());
     }
     if (new_active_client != nullptr)
         activateClient(new_active_client);
 }
 
 Workspace::~Workspace()
 {
     blockStackingUpdates(true);
 
     // TODO: grabXServer();
 
     // Use stacking_order, so that kwin --replace keeps stacking order
     const QList<Toplevel *> stack = stacking_order;
     // "mutex" the stackingorder, since anything trying to access it from now on will find
     // many dangeling pointers and crash
     stacking_order.clear();
 
     for (auto it = stack.constBegin(), end = stack.constEnd(); it != end; ++it) {
         X11Client *c = qobject_cast<X11Client *>(const_cast<Toplevel*>(*it));
         if (!c) {
             continue;
         }
         // Only release the window
         c->releaseWindow(true);
         // No removeClient() is called, it does more than just removing.
         // However, remove from some lists to e.g. prevent performTransiencyCheck()
         // from crashing.
         clients.removeAll(c);
         m_allClients.removeAll(c);
         desktops.removeAll(c);
     }
     X11Client::cleanupX11();
 
     if (waylandServer()) {
-        const QList<XdgShellClient *> shellClients = waylandServer()->clients();
-        for (XdgShellClient *shellClient : shellClients) {
-            shellClient->destroyClient();
+        // TODO: Introduce AbstractClient::destroy().
+        const QList<AbstractClient *> shellClients = waylandServer()->clients();
+        for (AbstractClient *client : shellClients) {
+            if (XdgShellClient *shellClient = qobject_cast<XdgShellClient *>(client)) {
+                shellClient->destroyClient();
+            }
         }
     }
 
     for (auto it = unmanaged.begin(), end = unmanaged.end(); it != end; ++it)
         (*it)->release(ReleaseReason::KWinShutsDown);
 
     for (InternalClient *client : m_internalClients) {
         client->destroyClient();
     }
 
     if (auto c = kwinApp()->x11Connection()) {
         xcb_delete_property(c, kwinApp()->x11RootWindow(), atoms->kwin_running);
     }
 
     for (auto it = deleted.begin(); it != deleted.end();) {
         emit deletedRemoved(*it);
         it = deleted.erase(it);
     }
 
     delete RuleBook::self();
     kwinApp()->config()->sync();
 
     RootInfo::destroy();
     delete startup;
     delete Placement::self();
     delete client_keys_dialog;
     foreach (SessionInfo * s, session)
     delete s;
 
     // TODO: ungrabXServer();
 
     Xcb::Extensions::destroy();
     _self = nullptr;
 }
 
 void Workspace::setupClientConnections(AbstractClient *c)
 {
     connect(c, &Toplevel::needsRepaint, m_compositor, &Compositor::scheduleRepaint);
     connect(c, &AbstractClient::desktopPresenceChanged, this, &Workspace::desktopPresenceChanged);
     connect(c, &AbstractClient::minimizedChanged, this, std::bind(&Workspace::clientMinimizedChanged, this, c));
 }
 
 X11Client *Workspace::createClient(xcb_window_t w, bool is_mapped)
 {
     StackingUpdatesBlocker blocker(this);
     X11Client *c = new X11Client();
     setupClientConnections(c);
     if (X11Compositor *compositor = X11Compositor::self()) {
         connect(c, &X11Client::blockingCompositingChanged, compositor, &X11Compositor::updateClientCompositeBlocking);
     }
     connect(c, SIGNAL(clientFullScreenSet(KWin::X11Client *,bool,bool)), ScreenEdges::self(), SIGNAL(checkBlocking()));
     if (!c->manage(w, is_mapped)) {
         X11Client::deleteClient(c);
         return nullptr;
     }
     addClient(c);
     return c;
 }
 
 Unmanaged* Workspace::createUnmanaged(xcb_window_t w)
 {
     if (X11Compositor *compositor = X11Compositor::self()) {
         if (compositor->checkForOverlayWindow(w)) {
             return nullptr;
         }
     }
     Unmanaged* c = new Unmanaged();
     if (!c->track(w)) {
         Unmanaged::deleteUnmanaged(c);
         return nullptr;
     }
     connect(c, &Unmanaged::needsRepaint, m_compositor, &Compositor::scheduleRepaint);
     addUnmanaged(c);
     emit unmanagedAdded(c);
     return c;
 }
 
 void Workspace::addClient(X11Client *c)
 {
     Group* grp = findGroup(c->window());
 
     emit clientAdded(c);
 
     if (grp != nullptr)
         grp->gotLeader(c);
 
     if (c->isDesktop()) {
         desktops.append(c);
         if (active_client == nullptr && should_get_focus.isEmpty() && c->isOnCurrentDesktop())
             requestFocus(c);   // TODO: Make sure desktop is active after startup if there's no other window active
     } else {
         FocusChain::self()->update(c, FocusChain::Update);
         clients.append(c);
         m_allClients.append(c);
     }
     if (!unconstrained_stacking_order.contains(c))
         unconstrained_stacking_order.append(c);   // Raise if it hasn't got any stacking position yet
     if (!stacking_order.contains(c))    // It'll be updated later, and updateToolWindows() requires
         stacking_order.append(c);      // c to be in stacking_order
     markXStackingOrderAsDirty();
     updateClientArea(); // This cannot be in manage(), because the client got added only now
     updateClientLayer(c);
     if (c->isDesktop()) {
         raiseClient(c);
         // If there's no active client, make this desktop the active one
         if (activeClient() == nullptr && should_get_focus.count() == 0)
             activateClient(findDesktop(true, VirtualDesktopManager::self()->current()));
     }
     c->checkActiveModal();
     checkTransients(c->window());   // SELI TODO: Does this really belong here?
     updateStackingOrder(true);   // Propagate new client
     if (c->isUtility() || c->isMenu() || c->isToolbar())
         updateToolWindows(true);
     updateTabbox();
 }
 
 void Workspace::addUnmanaged(Unmanaged* c)
 {
     unmanaged.append(c);
     markXStackingOrderAsDirty();
 }
 
 /**
  * Destroys the client \a c
  */
 void Workspace::removeClient(X11Client *c)
 {
     if (c == active_popup_client)
         closeActivePopup();
     if (m_userActionsMenu->isMenuClient(c)) {
         m_userActionsMenu->close();
     }
 
     if (client_keys_client == c)
         setupWindowShortcutDone(false);
     if (!c->shortcut().isEmpty()) {
         c->setShortcut(QString());   // Remove from client_keys
         clientShortcutUpdated(c);   // Needed, since this is otherwise delayed by setShortcut() and wouldn't run
     }
 
     Q_ASSERT(clients.contains(c) || desktops.contains(c));
     // TODO: if marked client is removed, notify the marked list
     clients.removeAll(c);
     m_allClients.removeAll(c);
     desktops.removeAll(c);
     markXStackingOrderAsDirty();
     attention_chain.removeAll(c);
     Group* group = findGroup(c->window());
     if (group != nullptr)
         group->lostLeader();
 
     if (c == most_recently_raised)
         most_recently_raised = nullptr;
     should_get_focus.removeAll(c);
     Q_ASSERT(c != active_client);
     if (c == last_active_client)
         last_active_client = nullptr;
     if (c == delayfocus_client)
         cancelDelayFocus();
 
     emit clientRemoved(c);
 
     updateStackingOrder(true);
     updateClientArea();
     updateTabbox();
 }
 
 void Workspace::removeUnmanaged(Unmanaged* c)
 {
     Q_ASSERT(unmanaged.contains(c));
     unmanaged.removeAll(c);
     emit unmanagedRemoved(c);
     markXStackingOrderAsDirty();
 }
 
 void Workspace::addDeleted(Deleted* c, Toplevel *orig)
 {
     Q_ASSERT(!deleted.contains(c));
     deleted.append(c);
     const int unconstraintedIndex = unconstrained_stacking_order.indexOf(orig);
     if (unconstraintedIndex != -1) {
         unconstrained_stacking_order.replace(unconstraintedIndex, c);
     } else {
         unconstrained_stacking_order.append(c);
     }
     const int index = stacking_order.indexOf(orig);
     if (index != -1) {
         stacking_order.replace(index, c);
     } else {
         stacking_order.append(c);
     }
     markXStackingOrderAsDirty();
     connect(c, &Deleted::needsRepaint, m_compositor, &Compositor::scheduleRepaint);
 }
 
 void Workspace::removeDeleted(Deleted* c)
 {
     Q_ASSERT(deleted.contains(c));
     emit deletedRemoved(c);
     deleted.removeAll(c);
     unconstrained_stacking_order.removeAll(c);
     stacking_order.removeAll(c);
     markXStackingOrderAsDirty();
     if (!c->wasClient()) {
         return;
     }
     if (X11Compositor *compositor = X11Compositor::self()) {
         compositor->updateClientCompositeBlocking();
     }
 }
 
+void Workspace::addShellClient(AbstractClient *client)
+{
+    setupClientConnections(client);
+    client->updateDecoration(false);
+    updateClientLayer(client);
+
+    const QRect area = clientArea(PlacementArea, Screens::self()->current(), client->desktop());
+    bool placementDone = false;
+    if (client->isInitialPositionSet()) {
+        placementDone = true;
+    }
+    if (client->isFullScreen()) {
+        placementDone = true;
+    }
+    if (client->maximizeMode() == MaximizeMode::MaximizeFull) {
+        placementDone = true;
+    }
+    if (client->rules()->checkPosition(invalidPoint, true) != invalidPoint) {
+        placementDone = true;
+    }
+    if (!placementDone) {
+        client->placeIn(area);
+    }
+    m_allClients.append(client);
+    if (!unconstrained_stacking_order.contains(client)) {
+        unconstrained_stacking_order.append(client); // Raise if it hasn't got any stacking position yet
+    }
+    if (!stacking_order.contains(client)) { // It'll be updated later, and updateToolWindows() requires
+        stacking_order.append(client);      // client to be in stacking_order
+    }
+
+    markXStackingOrderAsDirty();
+    updateStackingOrder(true);
+    updateClientArea();
+    if (client->wantsInput() && !client->isMinimized()) {
+        activateClient(client);
+    }
+    updateTabbox();
+    connect(client, &AbstractClient::windowShown, this, [this, client] {
+        updateClientLayer(client);
+        // TODO: when else should we send the client through placement?
+        if (client->hasTransientPlacementHint()) {
+            const QRect area = clientArea(PlacementArea, Screens::self()->current(), client->desktop());
+            client->placeIn(area);
+        }
+        markXStackingOrderAsDirty();
+        updateStackingOrder(true);
+        updateClientArea();
+        if (client->wantsInput()) {
+            activateClient(client);
+        }
+    });
+    connect(client, &AbstractClient::windowHidden, this, [this] {
+        // TODO: update tabbox if it's displayed
+        markXStackingOrderAsDirty();
+        updateStackingOrder(true);
+        updateClientArea();
+    });
+}
+
+void Workspace::removeShellClient(AbstractClient *client)
+{
+    m_allClients.removeAll(client);
+    if (client == most_recently_raised) {
+        most_recently_raised = nullptr;
+    }
+    if (client == delayfocus_client) {
+        cancelDelayFocus();
+    }
+    if (client == last_active_client) {
+        last_active_client = nullptr;
+    }
+    if (client_keys_client == client) {
+        setupWindowShortcutDone(false);
+    }
+    if (!client->shortcut().isEmpty()) {
+        client->setShortcut(QString());   // Remove from client_keys
+    }
+    clientHidden(client);
+    emit clientRemoved(client);
+    markXStackingOrderAsDirty();
+    updateStackingOrder(true);
+    updateClientArea();
+    updateTabbox();
+}
+
 void Workspace::updateToolWindows(bool also_hide)
 {
     // TODO: What if Client's transiency/group changes? should this be called too? (I'm paranoid, am I not?)
     if (!options->isHideUtilityWindowsForInactive()) {
         for (auto it = clients.constBegin(); it != clients.constEnd(); ++it)
             (*it)->hideClient(false);
         return;
     }
     const Group* group = nullptr;
     auto client = active_client;
     // Go up in transiency hiearchy, if the top is found, only tool transients for the top mainwindow
     // will be shown; if a group transient is group, all tools in the group will be shown
     while (client != nullptr) {
         if (!client->isTransient())
             break;
         if (client->groupTransient()) {
             group = client->group();
             break;
         }
         client = client->transientFor();
     }
     // Use stacking order only to reduce flicker, it doesn't matter if block_stacking_updates == 0,
     // I.e. if it's not up to date
 
     // SELI TODO: But maybe it should - what if a new client has been added that's not in stacking order yet?
     QVector<AbstractClient*> to_show, to_hide;
     for (auto it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         auto c = qobject_cast<AbstractClient*>(*it);
         if (!c) {
             continue;
         }
         if (c->isUtility() || c->isMenu() || c->isToolbar()) {
             bool show = true;
             if (!c->isTransient()) {
                 if (!c->group() || c->group()->members().count() == 1)   // Has its own group, keep always visible
                     show = true;
                 else if (client != nullptr && c->group() == client->group())
                     show = true;
                 else
                     show = false;
             } else {
                 if (group != nullptr && c->group() == group)
                     show = true;
                 else if (client != nullptr && client->hasTransient(c, true))
                     show = true;
                 else
                     show = false;
             }
             if (!show && also_hide) {
                 const auto mainclients = c->mainClients();
                 // Don't hide utility windows which are standalone(?) or
                 // have e.g. kicker as mainwindow
                 if (mainclients.isEmpty())
                     show = true;
                 for (auto it2 = mainclients.constBegin();
                         it2 != mainclients.constEnd();
                         ++it2) {
                     if ((*it2)->isSpecialWindow())
                         show = true;
                 }
                 if (!show)
                     to_hide.append(c);
             }
             if (show)
                 to_show.append(c);
         }
     } // First show new ones, then hide
     for (int i = to_show.size() - 1;
             i >= 0;
             --i)  // From topmost
         // TODO: Since this is in stacking order, the order of taskbar entries changes :(
         to_show.at(i)->hideClient(false);
     if (also_hide) {
         for (auto it = to_hide.constBegin();
                 it != to_hide.constEnd();
                 ++it)  // From bottommost
             (*it)->hideClient(true);
         updateToolWindowsTimer.stop();
     } else // setActiveClient() is after called with NULL client, quickly followed
         // by setting a new client, which would result in flickering
         resetUpdateToolWindowsTimer();
 }
 
 
 void Workspace::resetUpdateToolWindowsTimer()
 {
     updateToolWindowsTimer.start(200);
 }
 
 void Workspace::slotUpdateToolWindows()
 {
     updateToolWindows(true);
 }
 
 void Workspace::slotReloadConfig()
 {
     reconfigure();
 }
 
 void Workspace::reconfigure()
 {
     reconfigureTimer.start(200);
 }
 
 /**
  * Reread settings
  */
 
 void Workspace::slotReconfigure()
 {
     qCDebug(KWIN_CORE) << "Workspace::slotReconfigure()";
     reconfigureTimer.stop();
 
     bool borderlessMaximizedWindows = options->borderlessMaximizedWindows();
 
     kwinApp()->config()->reparseConfiguration();
     options->updateSettings();
 
     emit configChanged();
     m_userActionsMenu->discard();
     updateToolWindows(true);
 
     RuleBook::self()->load();
     for (auto it = m_allClients.begin();
             it != m_allClients.end();
             ++it) {
         (*it)->setupWindowRules(true);
         (*it)->applyWindowRules();
         RuleBook::self()->discardUsed(*it, false);
     }
 
     if (borderlessMaximizedWindows != options->borderlessMaximizedWindows() &&
             !options->borderlessMaximizedWindows()) {
         // in case borderless maximized windows option changed and new option
         // is to have borders, we need to unset the borders for all maximized windows
         for (auto it = m_allClients.begin();
                 it != m_allClients.end();
                 ++it) {
             if ((*it)->maximizeMode() == MaximizeFull)
                 (*it)->checkNoBorder();
         }
     }
 }
 
 void Workspace::slotCurrentDesktopChanged(uint oldDesktop, uint newDesktop)
 {
     closeActivePopup();
     ++block_focus;
     StackingUpdatesBlocker blocker(this);
     updateClientVisibilityOnDesktopChange(newDesktop);
     // Restore the focus on this desktop
     --block_focus;
 
     activateClientOnNewDesktop(newDesktop);
     emit currentDesktopChanged(oldDesktop, movingClient);
 }
 
 void Workspace::updateClientVisibilityOnDesktopChange(uint newDesktop)
 {
     for (auto it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         X11Client *c = qobject_cast<X11Client *>(*it);
         if (!c) {
             continue;
         }
         if (!c->isOnDesktop(newDesktop) && c != movingClient && c->isOnCurrentActivity()) {
             (c)->updateVisibility();
         }
     }
     // Now propagate the change, after hiding, before showing
     if (rootInfo()) {
         rootInfo()->setCurrentDesktop(VirtualDesktopManager::self()->current());
     }
 
     if (movingClient && !movingClient->isOnDesktop(newDesktop)) {
         movingClient->setDesktop(newDesktop);
     }
 
     for (int i = stacking_order.size() - 1; i >= 0 ; --i) {
         X11Client *c = qobject_cast<X11Client *>(stacking_order.at(i));
         if (!c) {
             continue;
         }
         if (c->isOnDesktop(newDesktop) && c->isOnCurrentActivity())
             c->updateVisibility();
     }
     if (showingDesktop())   // Do this only after desktop change to avoid flicker
         setShowingDesktop(false);
 }
 
 void Workspace::activateClientOnNewDesktop(uint desktop)
 {
     AbstractClient* c = nullptr;
     if (options->focusPolicyIsReasonable()) {
         c = findClientToActivateOnDesktop(desktop);
     }
     // If "unreasonable focus policy" and active_client is on_all_desktops and
     // under mouse (Hence == old_active_client), conserve focus.
     // (Thanks to Volker Schatz <V.Schatz at thphys.uni-heidelberg.de>)
     else if (active_client && active_client->isShown(true) && active_client->isOnCurrentDesktop())
         c = active_client;
 
     if (c == nullptr && !desktops.isEmpty())
         c = findDesktop(true, desktop);
 
     if (c != active_client)
         setActiveClient(nullptr);
 
     if (c)
         requestFocus(c);
     else if (!desktops.isEmpty())
         requestFocus(findDesktop(true, desktop));
     else
         focusToNull();
 }
 
 AbstractClient *Workspace::findClientToActivateOnDesktop(uint desktop)
 {
     if (movingClient != nullptr && active_client == movingClient &&
         FocusChain::self()->contains(active_client, desktop) &&
         active_client->isShown(true) && active_client->isOnCurrentDesktop()) {
         // A requestFocus call will fail, as the client is already active
         return active_client;
     }
     // from actiavtion.cpp
     if (options->isNextFocusPrefersMouse()) {
         auto it = stackingOrder().constEnd();
         while (it != stackingOrder().constBegin()) {
             X11Client *client = qobject_cast<X11Client *>(*(--it));
             if (!client) {
                 continue;
             }
 
             if (!(client->isShown(false) && client->isOnDesktop(desktop) &&
                 client->isOnCurrentActivity() && client->isOnActiveScreen()))
                 continue;
 
             if (client->frameGeometry().contains(Cursor::pos())) {
                 if (!client->isDesktop())
                     return client;
             break; // unconditional break  - we do not pass the focus to some client below an unusable one
             }
         }
     }
     return FocusChain::self()->getForActivation(desktop);
 }
 
 /**
  * Updates the current activity when it changes
  * do *not* call this directly; it does not set the activity.
  *
  * Shows/Hides windows according to the stacking order
  */
 
 void Workspace::updateCurrentActivity(const QString &new_activity)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     //closeActivePopup();
     ++block_focus;
     // TODO: Q_ASSERT( block_stacking_updates == 0 ); // Make sure stacking_order is up to date
     StackingUpdatesBlocker blocker(this);
 
     // Optimized Desktop switching: unmapping done from back to front
     // mapping done from front to back => less exposure events
     //Notify::raise((Notify::Event) (Notify::DesktopChange+new_desktop));
 
     for (auto it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         X11Client *c = qobject_cast<X11Client *>(*it);
         if (!c) {
             continue;
         }
         if (!c->isOnActivity(new_activity) && c != movingClient && c->isOnCurrentDesktop()) {
             c->updateVisibility();
         }
     }
 
     // Now propagate the change, after hiding, before showing
     //rootInfo->setCurrentDesktop( currentDesktop() );
 
     /* TODO someday enable dragging windows to other activities
     if ( movingClient && !movingClient->isOnDesktop( new_desktop ))
         {
         movingClient->setDesktop( new_desktop );
         */
 
     for (int i = stacking_order.size() - 1; i >= 0 ; --i) {
         X11Client *c = qobject_cast<X11Client *>(stacking_order.at(i));
         if (!c) {
             continue;
         }
         if (c->isOnActivity(new_activity))
             c->updateVisibility();
     }
 
     //FIXME not sure if I should do this either
     if (showingDesktop())   // Do this only after desktop change to avoid flicker
         setShowingDesktop(false);
 
     // Restore the focus on this desktop
     --block_focus;
     AbstractClient* c = nullptr;
 
     //FIXME below here is a lot of focuschain stuff, probably all wrong now
     if (options->focusPolicyIsReasonable()) {
         // Search in focus chain
         c = FocusChain::self()->getForActivation(VirtualDesktopManager::self()->current());
     }
     // If "unreasonable focus policy" and active_client is on_all_desktops and
     // under mouse (Hence == old_active_client), conserve focus.
     // (Thanks to Volker Schatz <V.Schatz at thphys.uni-heidelberg.de>)
     else if (active_client && active_client->isShown(true) && active_client->isOnCurrentDesktop() && active_client->isOnCurrentActivity())
         c = active_client;
 
     if (c == nullptr && !desktops.isEmpty())
         c = findDesktop(true, VirtualDesktopManager::self()->current());
 
     if (c != active_client)
         setActiveClient(nullptr);
 
     if (c)
         requestFocus(c);
     else if (!desktops.isEmpty())
         requestFocus(findDesktop(true, VirtualDesktopManager::self()->current()));
     else
         focusToNull();
 
     // Not for the very first time, only if something changed and there are more than 1 desktops
 
     //if ( effects != NULL && old_desktop != 0 && old_desktop != new_desktop )
     //    static_cast<EffectsHandlerImpl*>( effects )->desktopChanged( old_desktop );
     if (compositing() && m_compositor)
         m_compositor->addRepaintFull();
 #else
     Q_UNUSED(new_activity)
 #endif
 }
 
 void Workspace::slotDesktopCountChanged(uint previousCount, uint newCount)
 {
     Q_UNUSED(previousCount)
     Placement::self()->reinitCascading(0);
 
     resetClientAreas(newCount);
 }
 
 void Workspace::resetClientAreas(uint desktopCount)
 {
     // Make it +1, so that it can be accessed as [1..numberofdesktops]
     workarea.clear();
     workarea.resize(desktopCount + 1);
     restrictedmovearea.clear();
     restrictedmovearea.resize(desktopCount + 1);
     screenarea.clear();
 
     updateClientArea(true);
 }
 
 void Workspace::selectWmInputEventMask()
 {
     uint32_t presentMask = 0;
     Xcb::WindowAttributes attr(rootWindow());
     if (!attr.isNull()) {
         presentMask = attr->your_event_mask;
     }
 
     Xcb::selectInput(rootWindow(),
                      presentMask |
                      XCB_EVENT_MASK_KEY_PRESS |
                      XCB_EVENT_MASK_PROPERTY_CHANGE |
                      XCB_EVENT_MASK_COLOR_MAP_CHANGE |
                      XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
                      XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                      XCB_EVENT_MASK_FOCUS_CHANGE | // For NotifyDetailNone
                      XCB_EVENT_MASK_EXPOSURE
     );
 }
 
 /**
  * Sends client \a c to desktop \a desk.
  *
  * Takes care of transients as well.
  */
 void Workspace::sendClientToDesktop(AbstractClient* c, int desk, bool dont_activate)
 {
     if ((desk < 1 && desk != NET::OnAllDesktops) || desk > static_cast<int>(VirtualDesktopManager::self()->count()))
         return;
     int old_desktop = c->desktop();
     bool was_on_desktop = c->isOnDesktop(desk) || c->isOnAllDesktops();
     c->setDesktop(desk);
     if (c->desktop() != desk)   // No change or desktop forced
         return;
     desk = c->desktop(); // Client did range checking
 
     if (c->isOnDesktop(VirtualDesktopManager::self()->current())) {
         if (c->wantsTabFocus() && options->focusPolicyIsReasonable() &&
                 !was_on_desktop && // for stickyness changes
                 !dont_activate)
             requestFocus(c);
         else
             restackClientUnderActive(c);
     } else
         raiseClient(c);
 
     c->checkWorkspacePosition( QRect(), old_desktop );
 
     auto transients_stacking_order = ensureStackingOrder(c->transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it)
         sendClientToDesktop(*it, desk, dont_activate);
     updateClientArea();
 }
 
 /**
  * checks whether the X Window with the input focus is on our X11 screen
  * if the window cannot be determined or inspected, resturn depends on whether there's actually
  * more than one screen
  *
  * this is NOT in any way related to XRandR multiscreen
  *
  */
 extern bool is_multihead; // main.cpp
 bool Workspace::isOnCurrentHead()
 {
     if (!is_multihead) {
         return true;
     }
 
     Xcb::CurrentInput currentInput;
     if (currentInput.window() == XCB_WINDOW_NONE) {
         return !is_multihead;
     }
 
     Xcb::WindowGeometry geometry(currentInput.window());
     if (geometry.isNull()) { // should not happen
         return !is_multihead;
     }
 
     return rootWindow() == geometry->root;
 }
 
 void Workspace::sendClientToScreen(AbstractClient* c, int screen)
 {
     c->sendToScreen(screen);
 }
 
 void Workspace::sendPingToWindow(xcb_window_t window, xcb_timestamp_t timestamp)
 {
     if (rootInfo()) {
         rootInfo()->sendPing(window, timestamp);
     }
 }
 
 /**
  * Delayed focus functions
  */
 void Workspace::delayFocus()
 {
     requestFocus(delayfocus_client);
     cancelDelayFocus();
 }
 
 void Workspace::requestDelayFocus(AbstractClient* c)
 {
     delayfocus_client = c;
     delete delayFocusTimer;
     delayFocusTimer = new QTimer(this);
     connect(delayFocusTimer, SIGNAL(timeout()), this, SLOT(delayFocus()));
     delayFocusTimer->setSingleShot(true);
     delayFocusTimer->start(options->delayFocusInterval());
 }
 
 void Workspace::cancelDelayFocus()
 {
     delete delayFocusTimer;
     delayFocusTimer = nullptr;
 }
 
 bool Workspace::checkStartupNotification(xcb_window_t w, KStartupInfoId &id, KStartupInfoData &data)
 {
     return startup->checkStartup(w, id, data) == KStartupInfo::Match;
 }
 
 /**
  * Puts the focus on a dummy window
  * Just using XSetInputFocus() with None would block keyboard input
  */
 void Workspace::focusToNull()
 {
     if (m_nullFocus) {
         m_nullFocus->focus();
     }
 }
 
 void Workspace::setShowingDesktop(bool showing)
 {
     const bool changed = showing != showing_desktop;
     if (rootInfo() && changed) {
         rootInfo()->setShowingDesktop(showing);
     }
     showing_desktop = showing;
 
     AbstractClient *topDesk = nullptr;
 
     { // for the blocker RAII
     StackingUpdatesBlocker blocker(this); // updateLayer & lowerClient would invalidate stacking_order
     for (int i = stacking_order.count() - 1; i > -1; --i) {
         AbstractClient *c = qobject_cast<AbstractClient*>(stacking_order.at(i));
         if (c && c->isOnCurrentDesktop()) {
             if (c->isDock()) {
                 c->updateLayer();
             } else if (c->isDesktop() && c->isShown(true)) {
                 c->updateLayer();
                 lowerClient(c);
                 if (!topDesk)
                     topDesk = c;
                 if (auto group = c->group()) {
                     foreach (X11Client *cm, group->members()) {
                         cm->updateLayer();
                     }
                 }
             }
         }
     }
     } // ~StackingUpdatesBlocker
 
     if (showing_desktop && topDesk) {
         requestFocus(topDesk);
     } else if (!showing_desktop && changed) {
         const auto client = FocusChain::self()->getForActivation(VirtualDesktopManager::self()->current());
         if (client) {
             activateClient(client);
         }
     }
     if (changed)
         emit showingDesktopChanged(showing);
 }
 
 void Workspace::disableGlobalShortcutsForClient(bool disable)
 {
     if (global_shortcuts_disabled_for_client == disable)
         return;
     QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.kde.kglobalaccel"),
                                                           QStringLiteral("/kglobalaccel"),
                                                           QStringLiteral("org.kde.KGlobalAccel"),
                                                           QStringLiteral("blockGlobalShortcuts"));
     message.setArguments(QList<QVariant>() << disable);
     QDBusConnection::sessionBus().asyncCall(message);
 
     global_shortcuts_disabled_for_client = disable;
     // Update also Alt+LMB actions etc.
     for (auto it = clients.constBegin();
             it != clients.constEnd();
             ++it)
         (*it)->updateMouseGrab();
 }
 
 QString Workspace::supportInformation() const
 {
     QString support;
     const QString yes = QStringLiteral("yes\n");
     const QString no = QStringLiteral("no\n");
 
     support.append(ki18nc("Introductory text shown in the support information.",
         "KWin Support Information:\n"
         "The following information should be used when requesting support on e.g. https://forum.kde.org.\n"
         "It provides information about the currently running instance, which options are used,\n"
         "what OpenGL driver and which effects are running.\n"
         "Please post the information provided underneath this introductory text to a paste bin service\n"
         "like https://paste.kde.org instead of pasting into support threads.\n").toString());
     support.append(QStringLiteral("\n==========================\n\n"));
     // all following strings are intended for support. They need to be pasted to e.g forums.kde.org
     // it is expected that the support will happen in English language or that the people providing
     // help understand English. Because of that all texts are not translated
     support.append(QStringLiteral("Version\n"));
     support.append(QStringLiteral("=======\n"));
     support.append(QStringLiteral("KWin version: "));
     support.append(QStringLiteral(KWIN_VERSION_STRING));
     support.append(QStringLiteral("\n"));
     support.append(QStringLiteral("Qt Version: "));
     support.append(QString::fromUtf8(qVersion()));
     support.append(QStringLiteral("\n"));
     support.append(QStringLiteral("Qt compile version: %1\n").arg(QStringLiteral(QT_VERSION_STR)));
     support.append(QStringLiteral("XCB compile version: %1\n\n").arg(QStringLiteral(XCB_VERSION_STRING)));
     support.append(QStringLiteral("Operation Mode: "));
     switch (kwinApp()->operationMode()) {
     case Application::OperationModeX11:
         support.append(QStringLiteral("X11 only"));
         break;
     case Application::OperationModeWaylandOnly:
         support.append(QStringLiteral("Wayland Only"));
         break;
     case Application::OperationModeXwayland:
         support.append(QStringLiteral("Xwayland"));
         break;
     }
     support.append(QStringLiteral("\n\n"));
 
     support.append(QStringLiteral("Build Options\n"));
     support.append(QStringLiteral("=============\n"));
 
     support.append(QStringLiteral("KWIN_BUILD_DECORATIONS: "));
 #ifdef KWIN_BUILD_DECORATIONS
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("KWIN_BUILD_TABBOX: "));
 #ifdef KWIN_BUILD_TABBOX
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("KWIN_BUILD_ACTIVITIES: "));
 #ifdef KWIN_BUILD_ACTIVITIES
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_DRM: "));
 #if HAVE_DRM
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_GBM: "));
 #if HAVE_GBM
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_EGL_STREAMS: "));
 #if HAVE_EGL_STREAMS
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_X11_XCB: "));
 #if HAVE_X11_XCB
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_EPOXY_GLX: "));
 #if HAVE_EPOXY_GLX
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_WAYLAND_EGL: "));
 #if HAVE_WAYLAND_EGL
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("\n"));
 
     if (auto c = kwinApp()->x11Connection()) {
         support.append(QStringLiteral("X11\n"));
         support.append(QStringLiteral("===\n"));
         auto x11setup = xcb_get_setup(c);
         support.append(QStringLiteral("Vendor: %1\n").arg(QString::fromUtf8(QByteArray::fromRawData(xcb_setup_vendor(x11setup), xcb_setup_vendor_length(x11setup)))));
         support.append(QStringLiteral("Vendor Release: %1\n").arg(x11setup->release_number));
         support.append(QStringLiteral("Protocol Version/Revision: %1/%2\n").arg(x11setup->protocol_major_version).arg(x11setup->protocol_minor_version));
         const auto extensions = Xcb::Extensions::self()->extensions();
         for (const auto &e : extensions) {
             support.append(QStringLiteral("%1: %2; Version: 0x%3\n").arg(QString::fromUtf8(e.name))
                                                                     .arg(e.present ? yes.trimmed() : no.trimmed())
                                                                     .arg(QString::number(e.version, 16)));
         }
         support.append(QStringLiteral("\n"));
     }
 
     if (auto bridge = Decoration::DecorationBridge::self()) {
         support.append(QStringLiteral("Decoration\n"));
         support.append(QStringLiteral("==========\n"));
         support.append(bridge->supportInformation());
         support.append(QStringLiteral("\n"));
     }
     support.append(QStringLiteral("Platform\n"));
     support.append(QStringLiteral("==========\n"));
     support.append(kwinApp()->platform()->supportInformation());
     support.append(QStringLiteral("\n"));
 
     support.append(QStringLiteral("Options\n"));
     support.append(QStringLiteral("=======\n"));
     const QMetaObject *metaOptions = options->metaObject();
     auto printProperty = [] (const QVariant &variant) {
         if (variant.type() == QVariant::Size) {
             const QSize &s = variant.toSize();
             return QStringLiteral("%1x%2").arg(QString::number(s.width())).arg(QString::number(s.height()));
         }
         if (QLatin1String(variant.typeName()) == QLatin1String("KWin::OpenGLPlatformInterface") ||
                 QLatin1String(variant.typeName()) == QLatin1String("KWin::Options::WindowOperation")) {
             return QString::number(variant.toInt());
         }
         return variant.toString();
     };
     for (int i=0; i<metaOptions->propertyCount(); ++i) {
         const QMetaProperty property = metaOptions->property(i);
         if (QLatin1String(property.name()) == QLatin1String("objectName")) {
             continue;
         }
         support.append(QStringLiteral("%1: %2\n").arg(property.name()).arg(printProperty(options->property(property.name()))));
     }
     support.append(QStringLiteral("\nScreen Edges\n"));
     support.append(QStringLiteral(  "============\n"));
     const QMetaObject *metaScreenEdges = ScreenEdges::self()->metaObject();
     for (int i=0; i<metaScreenEdges->propertyCount(); ++i) {
         const QMetaProperty property = metaScreenEdges->property(i);
         if (QLatin1String(property.name()) == QLatin1String("objectName")) {
             continue;
         }
         support.append(QStringLiteral("%1: %2\n").arg(property.name()).arg(printProperty(ScreenEdges::self()->property(property.name()))));
     }
     support.append(QStringLiteral("\nScreens\n"));
     support.append(QStringLiteral(  "=======\n"));
     support.append(QStringLiteral("Multi-Head: "));
     if (is_multihead) {
         support.append(QStringLiteral("yes\n"));
         support.append(QStringLiteral("Head: %1\n").arg(screen_number));
     } else {
         support.append(QStringLiteral("no\n"));
     }
     support.append(QStringLiteral("Active screen follows mouse: "));
     if (screens()->isCurrentFollowsMouse())
         support.append(QStringLiteral(" yes\n"));
     else
         support.append(QStringLiteral(" no\n"));
     support.append(QStringLiteral("Number of Screens: %1\n\n").arg(screens()->count()));
     for (int i=0; i<screens()->count(); ++i) {
         const QRect geo = screens()->geometry(i);
         support.append(QStringLiteral("Screen %1:\n").arg(i));
         support.append(QStringLiteral("---------\n"));
         support.append(QStringLiteral("Name: %1\n").arg(screens()->name(i)));
         support.append(QStringLiteral("Geometry: %1,%2,%3x%4\n")
                               .arg(geo.x())
                               .arg(geo.y())
                               .arg(geo.width())
                               .arg(geo.height()));
         support.append(QStringLiteral("Scale: %1\n").arg(screens()->scale(i)));
         support.append(QStringLiteral("Refresh Rate: %1\n\n").arg(screens()->refreshRate(i)));
     }
     support.append(QStringLiteral("\nCompositing\n"));
     support.append(QStringLiteral(  "===========\n"));
     if (effects) {
         support.append(QStringLiteral("Compositing is active\n"));
         switch (effects->compositingType()) {
         case OpenGL2Compositing:
         case OpenGLCompositing: {
             GLPlatform *platform = GLPlatform::instance();
             if (platform->isGLES()) {
                 support.append(QStringLiteral("Compositing Type: OpenGL ES 2.0\n"));
             } else {
                 support.append(QStringLiteral("Compositing Type: OpenGL\n"));
             }
             support.append(QStringLiteral("OpenGL vendor string: ") +   QString::fromUtf8(platform->glVendorString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL renderer string: ") + QString::fromUtf8(platform->glRendererString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL version string: ") +  QString::fromUtf8(platform->glVersionString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL platform interface: "));
             switch (platform->platformInterface()) {
             case GlxPlatformInterface:
                 support.append(QStringLiteral("GLX"));
                 break;
             case EglPlatformInterface:
                 support.append(QStringLiteral("EGL"));
                 break;
             default:
                 support.append(QStringLiteral("UNKNOWN"));
             }
             support.append(QStringLiteral("\n"));
 
             if (platform->supports(LimitedGLSL) || platform->supports(GLSL))
                 support.append(QStringLiteral("OpenGL shading language version string: ") + QString::fromUtf8(platform->glShadingLanguageVersionString()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("Driver: ") + GLPlatform::driverToString(platform->driver()) + QStringLiteral("\n"));
             if (!platform->isMesaDriver())
                 support.append(QStringLiteral("Driver version: ") + GLPlatform::versionToString(platform->driverVersion()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("GPU class: ") + GLPlatform::chipClassToString(platform->chipClass()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("OpenGL version: ") + GLPlatform::versionToString(platform->glVersion()) + QStringLiteral("\n"));
 
             if (platform->supports(LimitedGLSL) || platform->supports(GLSL))
                 support.append(QStringLiteral("GLSL version: ") + GLPlatform::versionToString(platform->glslVersion()) + QStringLiteral("\n"));
 
             if (platform->isMesaDriver())
                 support.append(QStringLiteral("Mesa version: ") + GLPlatform::versionToString(platform->mesaVersion()) + QStringLiteral("\n"));
             if (platform->serverVersion() > 0)
                 support.append(QStringLiteral("X server version: ") + GLPlatform::versionToString(platform->serverVersion()) + QStringLiteral("\n"));
             if (platform->kernelVersion() > 0)
                 support.append(QStringLiteral("Linux kernel version: ") + GLPlatform::versionToString(platform->kernelVersion()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("Direct rendering: "));
             support.append(QStringLiteral("Requires strict binding: "));
             if (!platform->isLooseBinding()) {
                 support.append(QStringLiteral("yes\n"));
             } else {
                 support.append(QStringLiteral("no\n"));
             }
             support.append(QStringLiteral("GLSL shaders: "));
             if (platform->supports(GLSL)) {
                 if (platform->supports(LimitedGLSL)) {
                     support.append(QStringLiteral(" limited\n"));
                 } else {
                     support.append(QStringLiteral(" yes\n"));
                 }
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
             support.append(QStringLiteral("Texture NPOT support: "));
             if (platform->supports(TextureNPOT)) {
                 if (platform->supports(LimitedNPOT)) {
                     support.append(QStringLiteral(" limited\n"));
                 } else {
                     support.append(QStringLiteral(" yes\n"));
                 }
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
             support.append(QStringLiteral("Virtual Machine: "));
             if (platform->isVirtualMachine()) {
                 support.append(QStringLiteral(" yes\n"));
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
 
             support.append(QStringLiteral("OpenGL 2 Shaders are used\n"));
             support.append(QStringLiteral("Painting blocks for vertical retrace: "));
             if (m_compositor->scene()->blocksForRetrace())
                 support.append(QStringLiteral(" yes\n"));
             else
                 support.append(QStringLiteral(" no\n"));
             break;
         }
         case XRenderCompositing:
             support.append(QStringLiteral("Compositing Type: XRender\n"));
             break;
         case QPainterCompositing:
             support.append("Compositing Type: QPainter\n");
             break;
         case NoCompositing:
         default:
             support.append(QStringLiteral("Something is really broken, neither OpenGL nor XRender is used"));
         }
         support.append(QStringLiteral("\nLoaded Effects:\n"));
         support.append(QStringLiteral(  "---------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->loadedEffects()) {
             support.append(effect + QStringLiteral("\n"));
         }
         support.append(QStringLiteral("\nCurrently Active Effects:\n"));
         support.append(QStringLiteral(  "-------------------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->activeEffects()) {
             support.append(effect + QStringLiteral("\n"));
         }
         support.append(QStringLiteral("\nEffect Settings:\n"));
         support.append(QStringLiteral(  "----------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->loadedEffects()) {
             support.append(static_cast<EffectsHandlerImpl*>(effects)->supportInformation(effect));
             support.append(QStringLiteral("\n"));
         }
     } else {
         support.append(QStringLiteral("Compositing is not active\n"));
     }
     return support;
 }
 
 X11Client *Workspace::findClient(std::function<bool (const X11Client *)> func) const
 {
     if (X11Client *ret = Toplevel::findInList(clients, func)) {
         return ret;
     }
     if (X11Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     return nullptr;
 }
 
 AbstractClient *Workspace::findAbstractClient(std::function<bool (const AbstractClient*)> func) const
 {
     if (AbstractClient *ret = Toplevel::findInList(m_allClients, func)) {
         return ret;
     }
     if (X11Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     if (InternalClient *ret = Toplevel::findInList(m_internalClients, func)) {
         return ret;
     }
     return nullptr;
 }
 
 Unmanaged *Workspace::findUnmanaged(std::function<bool (const Unmanaged*)> func) const
 {
     return Toplevel::findInList(unmanaged, func);
 }
 
 Unmanaged *Workspace::findUnmanaged(xcb_window_t w) const
 {
     return findUnmanaged([w](const Unmanaged *u) {
         return u->window() == w;
     });
 }
 
 X11Client *Workspace::findClient(Predicate predicate, xcb_window_t w) const
 {
     switch (predicate) {
     case Predicate::WindowMatch:
         return findClient([w](const X11Client *c) {
             return c->window() == w;
         });
     case Predicate::WrapperIdMatch:
         return findClient([w](const X11Client *c) {
             return c->wrapperId() == w;
         });
     case Predicate::FrameIdMatch:
         return findClient([w](const X11Client *c) {
             return c->frameId() == w;
         });
     case Predicate::InputIdMatch:
         return findClient([w](const X11Client *c) {
             return c->inputId() == w;
         });
     }
     return nullptr;
 }
 
 Toplevel *Workspace::findToplevel(std::function<bool (const Toplevel*)> func) const
 {
     if (X11Client *ret = Toplevel::findInList(clients, func)) {
         return ret;
     }
     if (X11Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     if (Unmanaged *ret = Toplevel::findInList(unmanaged, func)) {
         return ret;
     }
     if (InternalClient *ret = Toplevel::findInList(m_internalClients, func)) {
         return ret;
     }
     return nullptr;
 }
 
 void Workspace::forEachToplevel(std::function<void (Toplevel *)> func)
 {
     std::for_each(m_allClients.constBegin(), m_allClients.constEnd(), func);
     std::for_each(desktops.constBegin(), desktops.constEnd(), func);
     std::for_each(deleted.constBegin(), deleted.constEnd(), func);
     std::for_each(unmanaged.constBegin(), unmanaged.constEnd(), func);
     std::for_each(m_internalClients.constBegin(), m_internalClients.constEnd(), func);
 }
 
 bool Workspace::hasClient(const AbstractClient *c)
 {
     if (auto cc = dynamic_cast<const X11Client *>(c)) {
         return hasClient(cc);
     } else {
         return findAbstractClient([c](const AbstractClient *test) {
             return test == c;
         }) != nullptr;
     }
     return false;
 }
 
 void Workspace::forEachAbstractClient(std::function< void (AbstractClient*) > func)
 {
     std::for_each(m_allClients.constBegin(), m_allClients.constEnd(), func);
     std::for_each(desktops.constBegin(), desktops.constEnd(), func);
     std::for_each(m_internalClients.constBegin(), m_internalClients.constEnd(), func);
 }
 
 Toplevel *Workspace::findInternal(QWindow *w) const
 {
     if (!w) {
         return nullptr;
     }
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         return findUnmanaged(w->winId());
     }
     for (InternalClient *client : m_internalClients) {
         if (client->internalWindow() == w) {
             return client;
         }
     }
     return nullptr;
 }
 
 bool Workspace::compositing() const
 {
     return m_compositor && m_compositor->scene();
 }
 
 void Workspace::markXStackingOrderAsDirty()
 {
     m_xStackingDirty = true;
     if (kwinApp()->x11Connection()) {
         m_xStackingQueryTree.reset(new Xcb::Tree(kwinApp()->x11RootWindow()));
     }
 }
 
 void Workspace::setWasUserInteraction()
 {
     if (was_user_interaction) {
         return;
     }
     was_user_interaction = true;
     // might be called from within the filter, so delay till we now the filter returned
     QTimer::singleShot(0, this,
         [this] {
             m_wasUserInteractionFilter.reset();
         }
     );
 }
 
 void Workspace::updateTabbox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox->isDisplayed()) {
         tabBox->reset(true);
     }
 #endif
 }
 
 void Workspace::addInternalClient(InternalClient *client)
 {
     m_internalClients.append(client);
 
     setupClientConnections(client);
     client->updateLayer();
 
     if (client->isDecorated()) {
         client->keepInArea(clientArea(FullScreenArea, client));
     }
 
     markXStackingOrderAsDirty();
     updateStackingOrder(true);
     updateClientArea();
 
     emit internalClientAdded(client);
 }
 
 void Workspace::removeInternalClient(InternalClient *client)
 {
     m_internalClients.removeOne(client);
 
     markXStackingOrderAsDirty();
     updateStackingOrder(true);
     updateClientArea();
 
     emit internalClientRemoved(client);
 }
 
 Group* Workspace::findGroup(xcb_window_t leader) const
 {
     Q_ASSERT(leader != XCB_WINDOW_NONE);
     for (auto it = groups.constBegin();
             it != groups.constEnd();
             ++it)
         if ((*it)->leader() == leader)
             return *it;
     return nullptr;
 }
 
 // Client is group transient, but has no group set. Try to find
 // group with windows with the same client leader.
 Group* Workspace::findClientLeaderGroup(const X11Client *c) const
 {
     Group* ret = nullptr;
     for (auto it = clients.constBegin();
             it != clients.constEnd();
             ++it) {
         if (*it == c)
             continue;
         if ((*it)->wmClientLeader() == c->wmClientLeader()) {
             if (ret == nullptr || ret == (*it)->group())
                 ret = (*it)->group();
             else {
                 // There are already two groups with the same client leader.
                 // This most probably means the app uses group transients without
                 // setting group for its windows. Merging the two groups is a bad
                 // hack, but there's no really good solution for this case.
                 QList<X11Client *> old_group = (*it)->group()->members();
                 // old_group autodeletes when being empty
                 for (int pos = 0;
                         pos < old_group.count();
                         ++pos) {
                     X11Client *tmp = old_group[ pos ];
                     if (tmp != c)
                         tmp->changeClientLeaderGroup(ret);
                 }
             }
         }
     }
     return ret;
 }
 
 void Workspace::updateMinimizedOfTransients(AbstractClient* c)
 {
     // if mainwindow is minimized or shaded, minimize transients too
     if (c->isMinimized()) {
         for (auto it = c->transients().constBegin();
                 it != c->transients().constEnd();
                 ++it) {
             if ((*it)->isModal())
                 continue; // there's no reason to hide modal dialogs with the main client
             // but to keep them to eg. watch progress or whatever
             if (!(*it)->isMinimized()) {
                 (*it)->minimize();
                 updateMinimizedOfTransients((*it));
             }
         }
         if (c->isModal()) { // if a modal dialog is minimized, minimize its mainwindow too
             foreach (AbstractClient * c2, c->mainClients())
             c2->minimize();
         }
     } else {
         // else unmiminize the transients
         for (auto it = c->transients().constBegin();
                 it != c->transients().constEnd();
                 ++it) {
             if ((*it)->isMinimized()) {
                 (*it)->unminimize();
                 updateMinimizedOfTransients((*it));
             }
         }
         if (c->isModal()) {
             foreach (AbstractClient * c2, c->mainClients())
             c2->unminimize();
         }
     }
 }
 
 
 /**
  * Sets the client \a c's transient windows' on_all_desktops property to \a on_all_desktops.
  */
 void Workspace::updateOnAllDesktopsOfTransients(AbstractClient* c)
 {
     for (auto it = c->transients().constBegin();
             it != c->transients().constEnd();
             ++it) {
         if ((*it)->isOnAllDesktops() != c->isOnAllDesktops())
             (*it)->setOnAllDesktops(c->isOnAllDesktops());
     }
 }
 
 // A new window has been mapped. Check if it's not a mainwindow for some already existing transient window.
 void Workspace::checkTransients(xcb_window_t w)
 {
     for (auto it = clients.constBegin();
             it != clients.constEnd();
             ++it)
         (*it)->checkTransient(w);
 }
 
 /**
  * Resizes the workspace after an XRANDR screen size change
  */
 void Workspace::desktopResized()
 {
     QRect geom = screens()->geometry();
     if (rootInfo()) {
         NETSize desktop_geometry;
         desktop_geometry.width = geom.width();
         desktop_geometry.height = geom.height();
         rootInfo()->setDesktopGeometry(desktop_geometry);
     }
 
     updateClientArea();
     saveOldScreenSizes(); // after updateClientArea(), so that one still uses the previous one
 
     // TODO: emit a signal instead and remove the deep function calls into edges and effects
     ScreenEdges::self()->recreateEdges();
 
     if (effects) {
         static_cast<EffectsHandlerImpl*>(effects)->desktopResized(geom.size());
     }
 }
 
 void Workspace::saveOldScreenSizes()
 {
     olddisplaysize = screens()->displaySize();
     oldscreensizes.clear();
     for( int i = 0;
          i < screens()->count();
          ++i )
         oldscreensizes.append( screens()->geometry( i ));
 }
 
 /**
  * Updates the current client areas according to the current clients.
  *
  * If the area changes or force is @c true, the new areas are propagated to the world.
  *
  * The client area is the area that is available for clients (that
  * which is not taken by windows like panels, the top-of-screen menu
  * etc).
  *
  * @see clientArea()
  */
 void Workspace::updateClientArea(bool force)
 {
     const Screens *s = Screens::self();
     int nscreens = s->count();
     const int numberOfDesktops = VirtualDesktopManager::self()->count();
     QVector< QRect > new_wareas(numberOfDesktops + 1);
     QVector< StrutRects > new_rmoveareas(numberOfDesktops + 1);
     QVector< QVector< QRect > > new_sareas(numberOfDesktops + 1);
     QVector< QRect > screens(nscreens);
     QRect desktopArea;
     for (int i = 0; i < nscreens; i++) {
         desktopArea |= s->geometry(i);
     }
     for (int iS = 0;
             iS < nscreens;
             iS ++) {
         screens [iS] = s->geometry(iS);
     }
     for (int i = 1;
             i <= numberOfDesktops;
             ++i) {
         new_wareas[ i ] = desktopArea;
         new_sareas[ i ].resize(nscreens);
         for (int iS = 0;
                 iS < nscreens;
                 iS ++)
             new_sareas[ i ][ iS ] = screens[ iS ];
     }
     for (auto it = clients.constBegin(); it != clients.constEnd(); ++it) {
         if (!(*it)->hasStrut())
             continue;
         QRect r = (*it)->adjustedClientArea(desktopArea, desktopArea);
         // sanity check that a strut doesn't exclude a complete screen geometry
         // this is a violation to EWMH, as KWin just ignores the strut
         for (int i = 0; i < Screens::self()->count(); i++) {
             if (!r.intersects(Screens::self()->geometry(i))) {
                 qCDebug(KWIN_CORE) << "Adjusted client area would exclude a complete screen, ignore";
                 r = desktopArea;
                 break;
             }
         }
         StrutRects strutRegion = (*it)->strutRects();
         const QRect clientsScreenRect = KWin::screens()->geometry((*it)->screen());
         for (auto strut = strutRegion.begin(); strut != strutRegion.end(); strut++) {
             *strut = StrutRect((*strut).intersected(clientsScreenRect), (*strut).area());
         }
 
         // Ignore offscreen xinerama struts. These interfere with the larger monitors on the setup
         // and should be ignored so that applications that use the work area to work out where
         // windows can go can use the entire visible area of the larger monitors.
         // This goes against the EWMH description of the work area but it is a toss up between
         // having unusable sections of the screen (Which can be quite large with newer monitors)
         // or having some content appear offscreen (Relatively rare compared to other).
         bool hasOffscreenXineramaStrut = (*it)->hasOffscreenXineramaStrut();
 
         if ((*it)->isOnAllDesktops()) {
             for (int i = 1;
                     i <= numberOfDesktops;
                     ++i) {
                 if (!hasOffscreenXineramaStrut)
                     new_wareas[ i ] = new_wareas[ i ].intersected(r);
                 new_rmoveareas[ i ] += strutRegion;
                 for (int iS = 0;
                         iS < nscreens;
                         iS ++) {
                     const auto geo = new_sareas[ i ][ iS ].intersected(
                                                 (*it)->adjustedClientArea(desktopArea, screens[ iS ]));
                     // ignore the geometry if it results in the screen getting removed completely
                     if (!geo.isEmpty()) {
                         new_sareas[ i ][ iS ] = geo;
                     }
                 }
             }
         } else {
             if (!hasOffscreenXineramaStrut)
                 new_wareas[(*it)->desktop()] = new_wareas[(*it)->desktop()].intersected(r);
             new_rmoveareas[(*it)->desktop()] += strutRegion;
             for (int iS = 0;
                     iS < nscreens;
                     iS ++) {
 //                            qDebug() << "adjusting new_sarea: " << screens[ iS ];
                 const auto geo = new_sareas[(*it)->desktop()][ iS ].intersected(
                       (*it)->adjustedClientArea(desktopArea, screens[ iS ]));
                 // ignore the geometry if it results in the screen getting removed completely
                 if (!geo.isEmpty()) {
                     new_sareas[(*it)->desktop()][ iS ] = geo;
                 }
             }
         }
     }
     if (waylandServer()) {
-        auto updateStrutsForWaylandClient = [&] (XdgShellClient *c) {
+        auto updateStrutsForWaylandClient = [&] (AbstractClient *c) {
             // assuming that only docks have "struts" and that all docks have a strut
             if (!c->hasStrut()) {
                 return;
             }
             auto margins = [c] (const QRect &geometry) {
                 QMargins margins;
                 if (!geometry.intersects(c->frameGeometry())) {
                     return margins;
                 }
                 // figure out which areas of the overall screen setup it borders
                 const bool left = c->frameGeometry().left() == geometry.left();
                 const bool right = c->frameGeometry().right() == geometry.right();
                 const bool top = c->frameGeometry().top() == geometry.top();
                 const bool bottom = c->frameGeometry().bottom() == geometry.bottom();
                 const bool horizontal = c->frameGeometry().width() >= c->frameGeometry().height();
                 if (left && ((!top && !bottom) || !horizontal)) {
                     margins.setLeft(c->frameGeometry().width());
                 }
                 if (right && ((!top && !bottom) || !horizontal)) {
                     margins.setRight(c->frameGeometry().width());
                 }
                 if (top && ((!left && !right) || horizontal)) {
                     margins.setTop(c->frameGeometry().height());
                 }
                 if (bottom && ((!left && !right) || horizontal)) {
                     margins.setBottom(c->frameGeometry().height());
                 }
                 return margins;
             };
             auto marginsToStrutArea = [] (const QMargins &margins) {
                 if (margins.left() != 0) {
                     return StrutAreaLeft;
                 }
                 if (margins.right() != 0) {
                     return StrutAreaRight;
                 }
                 if (margins.top() != 0) {
                     return StrutAreaTop;
                 }
                 if (margins.bottom() != 0) {
                     return StrutAreaBottom;
                 }
                 return StrutAreaInvalid;
             };
             const auto strut = margins(KWin::screens()->geometry(c->screen()));
             const StrutRects strutRegion = StrutRects{StrutRect(c->frameGeometry(), marginsToStrutArea(strut))};
             QRect r = desktopArea - margins(KWin::screens()->geometry());
             if (c->isOnAllDesktops()) {
                 for (int i = 1; i <= numberOfDesktops; ++i) {
                     new_wareas[ i ] = new_wareas[ i ].intersected(r);
                     for (int iS = 0; iS < nscreens; ++iS) {
                         new_sareas[ i ][ iS ] = new_sareas[ i ][ iS ].intersected(screens[iS] - margins(screens[iS]));
                     }
                     new_rmoveareas[ i ] += strutRegion;
                 }
             } else {
                 new_wareas[c->desktop()] = new_wareas[c->desktop()].intersected(r);
                 for (int iS = 0; iS < nscreens; iS++) {
                     new_sareas[c->desktop()][ iS ] = new_sareas[c->desktop()][ iS ].intersected(screens[iS] - margins(screens[iS]));
                 }
                 new_rmoveareas[ c->desktop() ] += strutRegion;
             }
         };
         const auto clients = waylandServer()->clients();
         for (auto c : clients) {
             updateStrutsForWaylandClient(c);
         }
     }
 #if 0
     for (int i = 1;
             i <= numberOfDesktops();
             ++i) {
         for (int iS = 0;
                 iS < nscreens;
                 iS ++)
             qCDebug(KWIN_CORE) << "new_sarea: " << new_sareas[ i ][ iS ];
     }
 #endif
 
     bool changed = force;
 
     if (screenarea.isEmpty())
         changed = true;
 
     for (int i = 1;
             !changed && i <= numberOfDesktops;
             ++i) {
         if (workarea[ i ] != new_wareas[ i ])
             changed = true;
         if (restrictedmovearea[ i ] != new_rmoveareas[ i ])
             changed = true;
         if (screenarea[ i ].size() != new_sareas[ i ].size())
             changed = true;
         for (int iS = 0;
                 !changed && iS < nscreens;
                 iS ++)
             if (new_sareas[ i ][ iS ] != screenarea [ i ][ iS ])
                 changed = true;
     }
 
     if (changed) {
         workarea = new_wareas;
         oldrestrictedmovearea = restrictedmovearea;
         restrictedmovearea = new_rmoveareas;
         screenarea = new_sareas;
         if (rootInfo()) {
             NETRect r;
             for (int i = 1; i <= numberOfDesktops; i++) {
                 r.pos.x = workarea[ i ].x();
                 r.pos.y = workarea[ i ].y();
                 r.size.width = workarea[ i ].width();
                 r.size.height = workarea[ i ].height();
                 rootInfo()->setWorkArea(i, r);
             }
         }
 
         for (auto it = m_allClients.constBegin();
                 it != m_allClients.constEnd();
                 ++it)
             (*it)->checkWorkspacePosition();
 
         oldrestrictedmovearea.clear(); // reset, no longer valid or needed
     }
 }
 
 void Workspace::updateClientArea()
 {
     updateClientArea(false);
 }
 
 
 /**
  * Returns the area available for clients. This is the desktop
  * geometry minus windows on the dock. Placement algorithms should
  * refer to this rather than Screens::geometry.
  */
 QRect Workspace::clientArea(clientAreaOption opt, int screen, int desktop) const
 {
     if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
         desktop = VirtualDesktopManager::self()->current();
     if (screen == -1)
         screen = screens()->current();
     const QSize displaySize = screens()->displaySize();
 
     QRect sarea, warea;
 
     if (is_multihead) {
         sarea = (!screenarea.isEmpty()
                    && screen < screenarea[ desktop ].size()) // screens may be missing during KWin initialization or screen config changes
                   ? screenarea[ desktop ][ screen_number ]
                   : screens()->geometry(screen_number);
         warea = workarea[ desktop ].isNull()
                 ? screens()->geometry(screen_number)
                 : workarea[ desktop ];
     } else {
         sarea = (!screenarea.isEmpty()
                 && screen < screenarea[ desktop ].size()) // screens may be missing during KWin initialization or screen config changes
                 ? screenarea[ desktop ][ screen ]
                 : screens()->geometry(screen);
         warea = workarea[ desktop ].isNull()
                 ? QRect(0, 0, displaySize.width(), displaySize.height())
                 : workarea[ desktop ];
     }
 
     switch(opt) {
     case MaximizeArea:
     case PlacementArea:
             return sarea;
     case MaximizeFullArea:
     case FullScreenArea:
     case MovementArea:
     case ScreenArea:
         if (is_multihead)
             return screens()->geometry(screen_number);
         else
             return screens()->geometry(screen);
     case WorkArea:
         if (is_multihead)
             return sarea;
         else
             return warea;
     case FullArea:
         return QRect(0, 0, displaySize.width(), displaySize.height());
     }
     abort();
 }
 
 
 QRect Workspace::clientArea(clientAreaOption opt, const QPoint& p, int desktop) const
 {
     return clientArea(opt, screens()->number(p), desktop);
 }
 
 QRect Workspace::clientArea(clientAreaOption opt, const AbstractClient* c) const
 {
     return clientArea(opt, c->frameGeometry().center(), c->desktop());
 }
 
 QRegion Workspace::restrictedMoveArea(int desktop, StrutAreas areas) const
 {
     if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
         desktop = VirtualDesktopManager::self()->current();
     QRegion region;
     foreach (const StrutRect & rect, restrictedmovearea[desktop])
     if (areas & rect.area())
         region += rect;
     return region;
 }
 
 bool Workspace::inUpdateClientArea() const
 {
     return !oldrestrictedmovearea.isEmpty();
 }
 
 QRegion Workspace::previousRestrictedMoveArea(int desktop, StrutAreas areas) const
 {
     if (desktop == NETWinInfo::OnAllDesktops || desktop == 0)
         desktop = VirtualDesktopManager::self()->current();
     QRegion region;
     foreach (const StrutRect & rect, oldrestrictedmovearea.at(desktop))
     if (areas & rect.area())
         region += rect;
     return region;
 }
 
 QVector< QRect > Workspace::previousScreenSizes() const
 {
     return oldscreensizes;
 }
 
 int Workspace::oldDisplayWidth() const
 {
     return olddisplaysize.width();
 }
 
 int Workspace::oldDisplayHeight() const
 {
     return olddisplaysize.height();
 }
 
 /**
  * Client \a c is moved around to position \a pos. This gives the
  * workspace the opportunity to interveniate and to implement
  * snap-to-windows functionality.
  *
  * The parameter \a snapAdjust is a multiplier used to calculate the
  * effective snap zones. When 1.0, it means that the snap zones will be
  * used without change.
  */
 QPoint Workspace::adjustClientPosition(AbstractClient* c, QPoint pos, bool unrestricted, double snapAdjust)
 {
     QSize borderSnapZone(options->borderSnapZone(), options->borderSnapZone());
     QRect maxRect;
     int guideMaximized = MaximizeRestore;
     if (c->maximizeMode() != MaximizeRestore) {
         maxRect = clientArea(MaximizeArea, pos + c->rect().center(), c->desktop());
         QRect geo = c->frameGeometry();
         if (c->maximizeMode() & MaximizeHorizontal && (geo.x() == maxRect.left() || geo.right() == maxRect.right())) {
             guideMaximized |= MaximizeHorizontal;
             borderSnapZone.setWidth(qMax(borderSnapZone.width() + 2, maxRect.width() / 16));
         }
         if (c->maximizeMode() & MaximizeVertical && (geo.y() == maxRect.top() || geo.bottom() == maxRect.bottom())) {
             guideMaximized |= MaximizeVertical;
             borderSnapZone.setHeight(qMax(borderSnapZone.height() + 2, maxRect.height() / 16));
         }
     }
 
     if (options->windowSnapZone() || !borderSnapZone.isNull() || options->centerSnapZone()) {
 
         const bool sOWO = options->isSnapOnlyWhenOverlapping();
         const int screen = screens()->number(pos + c->rect().center());
         if (maxRect.isNull())
             maxRect = clientArea(MovementArea, screen, c->desktop());
         const int xmin = maxRect.left();
         const int xmax = maxRect.right() + 1;             //desk size
         const int ymin = maxRect.top();
         const int ymax = maxRect.bottom() + 1;
 
         const int cx(pos.x());
         const int cy(pos.y());
         const int cw(c->width());
         const int ch(c->height());
         const int rx(cx + cw);
         const int ry(cy + ch);               //these don't change
 
         int nx(cx), ny(cy);                         //buffers
         int deltaX(xmax);
         int deltaY(ymax);   //minimum distance to other clients
 
         int lx, ly, lrx, lry; //coords and size for the comparison client, l
 
         // border snap
         const int snapX = borderSnapZone.width() * snapAdjust; //snap trigger
         const int snapY = borderSnapZone.height() * snapAdjust;
         if (snapX || snapY) {
             QRect geo = c->frameGeometry();
             QMargins frameMargins = c->frameMargins();
 
             // snap to titlebar / snap to window borders on inner screen edges
             AbstractClient::Position titlePos = c->titlebarPosition();
             if (frameMargins.left() && (titlePos == AbstractClient::PositionLeft || (c->maximizeMode() & MaximizeHorizontal) ||
                                         screens()->intersecting(geo.translated(maxRect.x() - (frameMargins.left() + geo.x()), 0)) > 1)) {
                 frameMargins.setLeft(0);
             }
             if (frameMargins.right() && (titlePos == AbstractClient::PositionRight || (c->maximizeMode() & MaximizeHorizontal) ||
                                          screens()->intersecting(geo.translated(maxRect.right() + frameMargins.right() - geo.right(), 0)) > 1)) {
                 frameMargins.setRight(0);
             }
             if (frameMargins.top() && (titlePos == AbstractClient::PositionTop || (c->maximizeMode() & MaximizeVertical) ||
                                        screens()->intersecting(geo.translated(0, maxRect.y() - (frameMargins.top() + geo.y()))) > 1)) {
                 frameMargins.setTop(0);
             }
             if (frameMargins.bottom() && (titlePos == AbstractClient::PositionBottom || (c->maximizeMode() & MaximizeVertical) ||
                                           screens()->intersecting(geo.translated(0, maxRect.bottom() + frameMargins.bottom() - geo.bottom())) > 1)) {
                 frameMargins.setBottom(0);
             }
             if ((sOWO ? (cx < xmin) : true) && (qAbs(xmin - cx) < snapX)) {
                 deltaX = xmin - cx;
                 nx = xmin - frameMargins.left();
             }
             if ((sOWO ? (rx > xmax) : true) && (qAbs(rx - xmax) < snapX) && (qAbs(xmax - rx) < deltaX)) {
                 deltaX = rx - xmax;
                 nx = xmax - cw + frameMargins.right();
             }
 
             if ((sOWO ? (cy < ymin) : true) && (qAbs(ymin - cy) < snapY)) {
                 deltaY = ymin - cy;
                 ny = ymin - frameMargins.top();
             }
             if ((sOWO ? (ry > ymax) : true) && (qAbs(ry - ymax) < snapY) && (qAbs(ymax - ry) < deltaY)) {
                 deltaY = ry - ymax;
                 ny = ymax - ch + frameMargins.bottom();
             }
         }
 
         // windows snap
         int snap = options->windowSnapZone() * snapAdjust;
         if (snap) {
             for (auto l = m_allClients.constBegin(); l != m_allClients.constEnd(); ++l) {
                 if ((*l) == c)
                     continue;
                 if ((*l)->isMinimized())
                     continue; // is minimized
                 if (!(*l)->isShown(false))
                     continue;
                 if (!((*l)->isOnDesktop(c->desktop()) || c->isOnDesktop((*l)->desktop())))
                     continue; // wrong virtual desktop
                 if (!(*l)->isOnCurrentActivity())
                     continue; // wrong activity
                 if ((*l)->isDesktop() || (*l)->isSplash())
                     continue;
 
                 lx = (*l)->x();
                 ly = (*l)->y();
                 lrx = lx + (*l)->width();
                 lry = ly + (*l)->height();
 
                 if (!(guideMaximized & MaximizeHorizontal) &&
                     (((cy <= lry) && (cy  >= ly)) || ((ry >= ly) && (ry  <= lry)) || ((cy <= ly) && (ry >= lry)))) {
                     if ((sOWO ? (cx < lrx) : true) && (qAbs(lrx - cx) < snap) && (qAbs(lrx - cx) < deltaX)) {
                         deltaX = qAbs(lrx - cx);
                         nx = lrx;
                     }
                     if ((sOWO ? (rx > lx) : true) && (qAbs(rx - lx) < snap) && (qAbs(rx - lx) < deltaX)) {
                         deltaX = qAbs(rx - lx);
                         nx = lx - cw;
                     }
                 }
 
                 if (!(guideMaximized & MaximizeVertical) &&
                     (((cx <= lrx) && (cx  >= lx)) || ((rx >= lx) && (rx  <= lrx)) || ((cx <= lx) && (rx >= lrx)))) {
                     if ((sOWO ? (cy < lry) : true) && (qAbs(lry - cy) < snap) && (qAbs(lry - cy) < deltaY)) {
                         deltaY = qAbs(lry - cy);
                         ny = lry;
                     }
                     //if ( (qAbs( ry-ly ) < snap) && (qAbs( ry - ly ) < deltaY ))
                     if ((sOWO ? (ry > ly) : true) && (qAbs(ry - ly) < snap) && (qAbs(ry - ly) < deltaY)) {
                         deltaY = qAbs(ry - ly);
                         ny = ly - ch;
                     }
                 }
 
                 // Corner snapping
                 if (!(guideMaximized & MaximizeVertical) && (nx == lrx || nx + cw == lx)) {
                     if ((sOWO ? (ry > lry) : true) && (qAbs(lry - ry) < snap) && (qAbs(lry - ry) < deltaY)) {
                         deltaY = qAbs(lry - ry);
                         ny = lry - ch;
                     }
                     if ((sOWO ? (cy < ly) : true) && (qAbs(cy - ly) < snap) && (qAbs(cy - ly) < deltaY)) {
                         deltaY = qAbs(cy - ly);
                         ny = ly;
                     }
                 }
                 if (!(guideMaximized & MaximizeHorizontal) && (ny == lry || ny + ch == ly)) {
                     if ((sOWO ? (rx > lrx) : true) && (qAbs(lrx - rx) < snap) && (qAbs(lrx - rx) < deltaX)) {
                         deltaX = qAbs(lrx - rx);
                         nx = lrx - cw;
                     }
                     if ((sOWO ? (cx < lx) : true) && (qAbs(cx - lx) < snap) && (qAbs(cx - lx) < deltaX)) {
                         deltaX = qAbs(cx - lx);
                         nx = lx;
                     }
                 }
             }
         }
 
         // center snap
         snap = options->centerSnapZone() * snapAdjust; //snap trigger
         if (snap) {
             int diffX = qAbs((xmin + xmax) / 2 - (cx + cw / 2));
             int diffY = qAbs((ymin + ymax) / 2 - (cy + ch / 2));
             if (diffX < snap && diffY < snap && diffX < deltaX && diffY < deltaY) {
                 // Snap to center of screen
                 nx = (xmin + xmax) / 2 - cw / 2;
                 ny = (ymin + ymax) / 2 - ch / 2;
             } else if (options->borderSnapZone()) {
                 // Enhance border snap
                 if ((nx == xmin || nx == xmax - cw) && diffY < snap && diffY < deltaY) {
                     // Snap to vertical center on screen edge
                     ny = (ymin + ymax) / 2 - ch / 2;
                 } else if (((unrestricted ? ny == ymin : ny <= ymin) || ny == ymax - ch) &&
                           diffX < snap && diffX < deltaX) {
                     // Snap to horizontal center on screen edge
                     nx = (xmin + xmax) / 2 - cw / 2;
                 }
             }
         }
 
         pos = QPoint(nx, ny);
     }
     return pos;
 }
 
 QRect Workspace::adjustClientSize(AbstractClient* c, QRect moveResizeGeom, int mode)
 {
     //adapted from adjustClientPosition on 29May2004
     //this function is called when resizing a window and will modify
     //the new dimensions to snap to other windows/borders if appropriate
     if (options->windowSnapZone() || options->borderSnapZone()) {  // || options->centerSnapZone )
         const bool sOWO = options->isSnapOnlyWhenOverlapping();
 
         const QRect maxRect = clientArea(MovementArea, c->rect().center(), c->desktop());
         const int xmin = maxRect.left();
         const int xmax = maxRect.right();               //desk size
         const int ymin = maxRect.top();
         const int ymax = maxRect.bottom();
 
         const int cx(moveResizeGeom.left());
         const int cy(moveResizeGeom.top());
         const int rx(moveResizeGeom.right());
         const int ry(moveResizeGeom.bottom());
 
         int newcx(cx), newcy(cy);                         //buffers
         int newrx(rx), newry(ry);
         int deltaX(xmax);
         int deltaY(ymax);   //minimum distance to other clients
 
         int lx, ly, lrx, lry; //coords and size for the comparison client, l
 
         // border snap
         int snap = options->borderSnapZone(); //snap trigger
         if (snap) {
             deltaX = int(snap);
             deltaY = int(snap);
 
 #define SNAP_BORDER_TOP \
     if ((sOWO?(newcy<ymin):true) && (qAbs(ymin-newcy)<deltaY)) \
     { \
         deltaY = qAbs(ymin-newcy); \
         newcy = ymin; \
     }
 
 #define SNAP_BORDER_BOTTOM \
     if ((sOWO?(newry>ymax):true) && (qAbs(ymax-newry)<deltaY)) \
     { \
         deltaY = qAbs(ymax-newcy); \
         newry = ymax; \
     }
 
 #define SNAP_BORDER_LEFT \
     if ((sOWO?(newcx<xmin):true) && (qAbs(xmin-newcx)<deltaX)) \
     { \
         deltaX = qAbs(xmin-newcx); \
         newcx = xmin; \
     }
 
 #define SNAP_BORDER_RIGHT \
     if ((sOWO?(newrx>xmax):true) && (qAbs(xmax-newrx)<deltaX)) \
     { \
         deltaX = qAbs(xmax-newrx); \
         newrx = xmax; \
     }
             switch(mode) {
             case AbstractClient::PositionBottomRight:
                 SNAP_BORDER_BOTTOM
                 SNAP_BORDER_RIGHT
                 break;
             case AbstractClient::PositionRight:
                 SNAP_BORDER_RIGHT
                 break;
             case AbstractClient::PositionBottom:
                 SNAP_BORDER_BOTTOM
                 break;
             case AbstractClient::PositionTopLeft:
                 SNAP_BORDER_TOP
                 SNAP_BORDER_LEFT
                 break;
             case AbstractClient::PositionLeft:
                 SNAP_BORDER_LEFT
                 break;
             case AbstractClient::PositionTop:
                 SNAP_BORDER_TOP
                 break;
             case AbstractClient::PositionTopRight:
                 SNAP_BORDER_TOP
                 SNAP_BORDER_RIGHT
                 break;
             case AbstractClient::PositionBottomLeft:
                 SNAP_BORDER_BOTTOM
                 SNAP_BORDER_LEFT
                 break;
             default:
                 abort();
                 break;
             }
 
 
         }
 
         // windows snap
         snap = options->windowSnapZone();
         if (snap) {
             deltaX = int(snap);
             deltaY = int(snap);
             for (auto l = m_allClients.constBegin(); l != m_allClients.constEnd(); ++l) {
                 if ((*l)->isOnDesktop(VirtualDesktopManager::self()->current()) &&
                         !(*l)->isMinimized()
                         && (*l) != c) {
                     lx = (*l)->x() - 1;
                     ly = (*l)->y() - 1;
                     lrx = (*l)->x() + (*l)->width();
                     lry = (*l)->y() + (*l)->height();
 
 #define WITHIN_HEIGHT ((( newcy <= lry ) && ( newcy  >= ly  ))  || \
                        (( newry >= ly  ) && ( newry  <= lry ))  || \
                        (( newcy <= ly  ) && ( newry >= lry  )) )
 
 #define WITHIN_WIDTH  ( (( cx <= lrx ) && ( cx  >= lx  ))  || \
                         (( rx >= lx  ) && ( rx  <= lrx ))  || \
                         (( cx <= lx  ) && ( rx >= lrx  )) )
 
 #define SNAP_WINDOW_TOP  if ( (sOWO?(newcy<lry):true) \
                               && WITHIN_WIDTH  \
                               && (qAbs( lry - newcy ) < deltaY) ) {  \
     deltaY = qAbs( lry - newcy ); \
     newcy=lry; \
 }
 
 #define SNAP_WINDOW_BOTTOM  if ( (sOWO?(newry>ly):true)  \
                                  && WITHIN_WIDTH  \
                                  && (qAbs( ly - newry ) < deltaY) ) {  \
     deltaY = qAbs( ly - newry );  \
     newry=ly;  \
 }
 
 #define SNAP_WINDOW_LEFT  if ( (sOWO?(newcx<lrx):true)  \
                                && WITHIN_HEIGHT  \
                                && (qAbs( lrx - newcx ) < deltaX)) {  \
     deltaX = qAbs( lrx - newcx );  \
     newcx=lrx;  \
 }
 
 #define SNAP_WINDOW_RIGHT  if ( (sOWO?(newrx>lx):true)  \
                                 && WITHIN_HEIGHT  \
                                 && (qAbs( lx - newrx ) < deltaX))  \
 {  \
     deltaX = qAbs( lx - newrx );  \
     newrx=lx;  \
 }
 
 #define SNAP_WINDOW_C_TOP  if ( (sOWO?(newcy<ly):true)  \
                                 && (newcx == lrx || newrx == lx)  \
                                 && qAbs(ly-newcy) < deltaY ) {  \
     deltaY = qAbs( ly - newcy + 1 ); \
     newcy = ly + 1; \
 }
 
 #define SNAP_WINDOW_C_BOTTOM  if ( (sOWO?(newry>lry):true)  \
                                    && (newcx == lrx || newrx == lx)  \
                                    && qAbs(lry-newry) < deltaY ) {  \
     deltaY = qAbs( lry - newry - 1 ); \
     newry = lry - 1; \
 }
 
 #define SNAP_WINDOW_C_LEFT  if ( (sOWO?(newcx<lx):true)  \
                                  && (newcy == lry || newry == ly)  \
                                  && qAbs(lx-newcx) < deltaX ) {  \
     deltaX = qAbs( lx - newcx + 1 ); \
     newcx = lx + 1; \
 }
 
 #define SNAP_WINDOW_C_RIGHT  if ( (sOWO?(newrx>lrx):true)  \
                                   && (newcy == lry || newry == ly)  \
                                   && qAbs(lrx-newrx) < deltaX ) {  \
     deltaX = qAbs( lrx - newrx - 1 ); \
     newrx = lrx - 1; \
 }
 
                     switch(mode) {
                     case AbstractClient::PositionBottomRight:
                         SNAP_WINDOW_BOTTOM
                         SNAP_WINDOW_RIGHT
                         SNAP_WINDOW_C_BOTTOM
                         SNAP_WINDOW_C_RIGHT
                         break;
                     case AbstractClient::PositionRight:
                         SNAP_WINDOW_RIGHT
                         SNAP_WINDOW_C_RIGHT
                         break;
                     case AbstractClient::PositionBottom:
                         SNAP_WINDOW_BOTTOM
                         SNAP_WINDOW_C_BOTTOM
                         break;
                     case AbstractClient::PositionTopLeft:
                         SNAP_WINDOW_TOP
                         SNAP_WINDOW_LEFT
                         SNAP_WINDOW_C_TOP
                         SNAP_WINDOW_C_LEFT
                         break;
                     case AbstractClient::PositionLeft:
                         SNAP_WINDOW_LEFT
                         SNAP_WINDOW_C_LEFT
                         break;
                     case AbstractClient::PositionTop:
                         SNAP_WINDOW_TOP
                         SNAP_WINDOW_C_TOP
                         break;
                     case AbstractClient::PositionTopRight:
                         SNAP_WINDOW_TOP
                         SNAP_WINDOW_RIGHT
                         SNAP_WINDOW_C_TOP
                         SNAP_WINDOW_C_RIGHT
                         break;
                     case AbstractClient::PositionBottomLeft:
                         SNAP_WINDOW_BOTTOM
                         SNAP_WINDOW_LEFT
                         SNAP_WINDOW_C_BOTTOM
                         SNAP_WINDOW_C_LEFT
                         break;
                     default:
                         abort();
                         break;
                     }
                 }
             }
         }
 
         // center snap
         //snap = options->centerSnapZone;
         //if (snap)
         //    {
         //    // Don't resize snap to center as it interferes too much
         //    // There are two ways of implementing this if wanted:
         //    // 1) Snap only to the same points that the move snap does, and
         //    // 2) Snap to the horizontal and vertical center lines of the screen
         //    }
 
         moveResizeGeom = QRect(QPoint(newcx, newcy), QPoint(newrx, newry));
     }
     return moveResizeGeom;
 }
 
 /**
  * Marks the client as being moved or resized by the user.
  */
 void Workspace::setMoveResizeClient(AbstractClient *c)
 {
     Q_ASSERT(!c || !movingClient); // Catch attempts to move a second
     // window while still moving the first one.
     movingClient = c;
     if (movingClient)
         ++block_focus;
     else
         --block_focus;
 }
 
 // When kwin crashes, windows will not be gravitated back to their original position
 // and will remain offset by the size of the decoration. So when restarting, fix this
 // (the property with the size of the frame remains on the window after the crash).
 void Workspace::fixPositionAfterCrash(xcb_window_t w, const xcb_get_geometry_reply_t *geometry)
 {
     NETWinInfo i(connection(), w, rootWindow(), NET::WMFrameExtents, NET::Properties2());
     NETStrut frame = i.frameExtents();
 
     if (frame.left != 0 || frame.top != 0) {
         // left and top needed due to narrowing conversations restrictions in C++11
         const uint32_t left = frame.left;
         const uint32_t top = frame.top;
         const uint32_t values[] = { geometry->x - left, geometry->y - top };
         xcb_configure_window(connection(), w, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);
     }
 }
 
 } // namespace
diff --git a/workspace.h b/workspace.h
index 547750c5c..f45bd12d0 100644
--- a/workspace.h
+++ b/workspace.h
@@ -1,808 +1,811 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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_WORKSPACE_H
 #define KWIN_WORKSPACE_H
 
 // kwin
 #include "options.h"
 #include "sm.h"
 #include "utils.h"
 // Qt
 #include <QTimer>
 #include <QVector>
 // std
 #include <functional>
 #include <memory>
 
 class KConfig;
 class KConfigGroup;
 class KStartupInfo;
 class KStartupInfoData;
 class KStartupInfoId;
 class QStringList;
 
 namespace KWin
 {
 
 namespace Xcb
 {
 class Tree;
 class Window;
 }
 
 class AbstractClient;
 class Compositor;
 class Deleted;
 class Group;
 class InternalClient;
 class KillWindow;
 class ShortcutDialog;
 class Toplevel;
 class Unmanaged;
 class UserActionsMenu;
 class X11Client;
 class X11EventFilter;
 enum class Predicate;
 
 class KWIN_EXPORT Workspace : public QObject
 {
     Q_OBJECT
 public:
     explicit Workspace(const QString &sessionKey = QString());
     ~Workspace() override;
 
     static Workspace* self() {
         return _self;
     }
 
     bool workspaceEvent(xcb_generic_event_t*);
     bool workspaceEvent(QEvent*);
 
     bool hasClient(const X11Client *);
     bool hasClient(const AbstractClient*);
 
     /**
      * @brief Finds the first Client matching the condition expressed by passed in @p func.
      *
      * Internally findClient uses the std::find_if algorithm and that determines how the function
      * needs to be implemented. An example usage for finding a Client with a matching windowId
      * @code
      * xcb_window_t w; // our test window
      * X11Client *client = findClient([w](const X11Client *c) -> bool {
      *     return c->window() == w;
      * });
      * @endcode
      *
      * For the standard cases of matching the window id with one of the Client's windows use
      * the simplified overload method findClient(Predicate, xcb_window_t). Above example
      * can be simplified to:
      * @code
      * xcb_window_t w; // our test window
      * X11Client *client = findClient(Predicate::WindowMatch, w);
      * @endcode
      *
      * @param func Unary function that accepts a X11Client *as argument and
      * returns a value convertible to bool. The value returned indicates whether the
      * X11Client *is considered a match in the context of this function.
      * The function shall not modify its argument.
      * This can either be a function pointer or a function object.
      * @return KWin::X11Client *The found Client or @c null
      * @see findClient(Predicate, xcb_window_t)
      */
     X11Client *findClient(std::function<bool (const X11Client *)> func) const;
     AbstractClient *findAbstractClient(std::function<bool (const AbstractClient*)> func) const;
     /**
      * @brief Finds the Client matching the given match @p predicate for the given window.
      *
      * @param predicate Which window should be compared
      * @param w The window id to test against
      * @return KWin::X11Client *The found Client or @c null
      * @see findClient(std::function<bool (const X11Client *)>)
      */
     X11Client *findClient(Predicate predicate, xcb_window_t w) const;
     void forEachClient(std::function<void (X11Client *)> func);
     void forEachAbstractClient(std::function<void (AbstractClient*)> func);
     Unmanaged *findUnmanaged(std::function<bool (const Unmanaged*)> func) const;
     /**
      * @brief Finds the Unmanaged with the given window id.
      *
      * @param w The window id to search for
      * @return KWin::Unmanaged* Found Unmanaged or @c null if there is no Unmanaged with given Id.
      */
     Unmanaged *findUnmanaged(xcb_window_t w) const;
     void forEachUnmanaged(std::function<void (Unmanaged*)> func);
     Toplevel *findToplevel(std::function<bool (const Toplevel*)> func) const;
     void forEachToplevel(std::function<void (Toplevel *)> func);
     /**
      * @brief Finds a Toplevel for the internal window @p w.
      *
      * Internal window means a window created by KWin itself. On X11 this is an Unmanaged
      * and mapped by the window id, on Wayland a XdgShellClient mapped on the internal window id.
      *
      * @returns Toplevel
      */
     Toplevel *findInternal(QWindow *w) const;
 
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const;
     QRect clientArea(clientAreaOption, const AbstractClient* c) const;
     QRect clientArea(clientAreaOption, int screen, int desktop) const;
 
     QRegion restrictedMoveArea(int desktop, StrutAreas areas = StrutAreaAll) const;
 
     bool initializing() const;
 
     /**
      * Returns the active client, i.e. the client that has the focus (or None
      * if no client has the focus)
      */
     AbstractClient* activeClient() const;
     /**
      * Client that was activated, but it's not yet really activeClient(), because
      * we didn't process yet the matching FocusIn event. Used mostly in focus
      * stealing prevention code.
      */
     AbstractClient* mostRecentlyActivatedClient() const;
 
     AbstractClient* clientUnderMouse(int screen) const;
 
     void activateClient(AbstractClient*, bool force = false);
     void requestFocus(AbstractClient* c, bool force = false);
     enum ActivityFlag {
         ActivityFocus = 1 << 0, // focus the window
         ActivityFocusForce = 1 << 1 | ActivityFocus, // focus even if Dock etc.
         ActivityRaise = 1 << 2 // raise the window
     };
     Q_DECLARE_FLAGS(ActivityFlags, ActivityFlag)
     void takeActivity(AbstractClient* c, ActivityFlags flags);
     bool allowClientActivation(const AbstractClient* c, xcb_timestamp_t time = -1U, bool focus_in = false,
                                bool ignore_desktop = false);
     void restoreFocus();
     void gotFocusIn(const AbstractClient*);
     void setShouldGetFocus(AbstractClient*);
     bool activateNextClient(AbstractClient* c);
     bool focusChangeEnabled() {
         return block_focus == 0;
     }
 
     /**
      * Indicates that the client c is being moved or resized by the user.
      */
     void setMoveResizeClient(AbstractClient* c);
 
     QPoint adjustClientPosition(AbstractClient* c, QPoint pos, bool unrestricted, double snapAdjust = 1.0);
     QRect adjustClientSize(AbstractClient* c, QRect moveResizeGeom, int mode);
     void raiseClient(AbstractClient* c, bool nogroup = false);
     void lowerClient(AbstractClient* c, bool nogroup = false);
     void raiseClientRequest(AbstractClient* c, NET::RequestSource src = NET::FromApplication, xcb_timestamp_t timestamp = 0);
     void lowerClientRequest(X11Client *c, NET::RequestSource src, xcb_timestamp_t timestamp);
     void lowerClientRequest(AbstractClient* c);
     void restackClientUnderActive(AbstractClient*);
     void restack(AbstractClient *c, AbstractClient *under, bool force = false);
     void updateClientLayer(AbstractClient* c);
     void raiseOrLowerClient(AbstractClient*);
     void resetUpdateToolWindowsTimer();
     void restoreSessionStackingOrder(X11Client *c);
     void updateStackingOrder(bool propagate_new_clients = false);
     void forceRestacking();
 
     void clientHidden(AbstractClient*);
     void clientAttentionChanged(AbstractClient* c, bool set);
 
     /**
      * @return List of clients currently managed by Workspace
      */
     const QList<X11Client *> &clientList() const {
         return clients;
     }
     /**
      * @return List of unmanaged "clients" currently registered in Workspace
      */
     const QList<Unmanaged *> &unmanagedList() const {
         return unmanaged;
     }
     /**
      * @return List of desktop "clients" currently managed by Workspace
      */
     const QList<X11Client *> &desktopList() const {
         return desktops;
     }
     /**
      * @return List of deleted "clients" currently managed by Workspace
      */
     const QList<Deleted *> &deletedList() const {
         return deleted;
     }
     /**
      * @returns List of all clients (either X11 or Wayland) currently managed by Workspace
      */
     const QList<AbstractClient*> allClientList() const {
         return m_allClients;
     }
 
     /**
      * @returns List of all internal clients currently managed by Workspace
      */
     const QList<InternalClient *> &internalClients() const {
         return m_internalClients;
     }
 
     void stackScreenEdgesUnderOverrideRedirect();
 
     SessionManager *sessionManager() const;
 
 public:
     QPoint cascadeOffset(const AbstractClient *c) const;
 
 private:
     Compositor *m_compositor;
 
     //-------------------------------------------------
     // Unsorted
 
 public:
     bool isOnCurrentHead();
     // True when performing Workspace::updateClientArea().
     // The calls below are valid only in that case.
     bool inUpdateClientArea() const;
     QRegion previousRestrictedMoveArea(int desktop, StrutAreas areas = StrutAreaAll) const;
     QVector< QRect > previousScreenSizes() const;
     int oldDisplayWidth() const;
     int oldDisplayHeight() const;
 
     /**
      * Returns the list of clients sorted in stacking order, with topmost client
      * at the last position
      */
     const QList<Toplevel *> &stackingOrder() const;
     QList<Toplevel *> xStackingOrder() const;
     QList<X11Client *> ensureStackingOrder(const QList<X11Client *> &clients) const;
     QList<AbstractClient*> ensureStackingOrder(const QList<AbstractClient*> &clients) const;
 
     AbstractClient* topClientOnDesktop(int desktop, int screen, bool unconstrained = false,
                                bool only_normal = true) const;
     AbstractClient* findDesktop(bool topmost, int desktop) const;
     void sendClientToDesktop(AbstractClient* c, int desktop, bool dont_activate);
     void windowToPreviousDesktop(AbstractClient* c);
     void windowToNextDesktop(AbstractClient* c);
     void sendClientToScreen(AbstractClient* c, int screen);
 
     void addManualOverlay(xcb_window_t id) {
         manual_overlays << id;
     }
     void removeManualOverlay(xcb_window_t id) {
         manual_overlays.removeOne(id);
     }
 
     /**
      * Shows the menu operations menu for the client and makes it active if
      * it's not already.
      */
     void showWindowMenu(const QRect& pos, AbstractClient* cl);
     const UserActionsMenu *userActionsMenu() const {
         return m_userActionsMenu;
     }
 
     void showApplicationMenu(const QRect &pos, AbstractClient *c, int actionId);
 
     void updateMinimizedOfTransients(AbstractClient*);
     void updateOnAllDesktopsOfTransients(AbstractClient*);
     void checkTransients(xcb_window_t w);
 
     void storeSession(KConfig* config, SMSavePhase phase);
     void storeClient(KConfigGroup &cg, int num, X11Client *c);
     void storeSubSession(const QString &name, QSet<QByteArray> sessionIds);
     void loadSubSessionInfo(const QString &name);
 
     SessionInfo* takeSessionInfo(X11Client *);
 
     // D-Bus interface
     QString supportInformation() const;
 
     void setCurrentScreen(int new_screen);
 
     void setShowingDesktop(bool showing);
     bool showingDesktop() const;
 
     void sendPingToWindow(xcb_window_t w, xcb_timestamp_t timestamp);   // Called from X11Client::pingWindow()
 
     void removeClient(X11Client *);   // Only called from X11Client::destroyClient() or X11Client::releaseWindow()
     void setActiveClient(AbstractClient*);
     Group* findGroup(xcb_window_t leader) const;
     void addGroup(Group* group);
     void removeGroup(Group* group);
     Group* findClientLeaderGroup(const X11Client *c) const;
 
     void removeUnmanaged(Unmanaged*);   // Only called from Unmanaged::release()
     void removeDeleted(Deleted*);
     void addDeleted(Deleted*, Toplevel*);
 
     bool checkStartupNotification(xcb_window_t w, KStartupInfoId& id, KStartupInfoData& data);
 
     void focusToNull(); // SELI TODO: Public?
 
     void clientShortcutUpdated(AbstractClient* c);
     bool shortcutAvailable(const QKeySequence &cut, AbstractClient* ignore = nullptr) const;
     bool globalShortcutsDisabled() const;
     void disableGlobalShortcutsForClient(bool disable);
 
     void setWasUserInteraction();
     bool wasUserInteraction() const;
 
     int packPositionLeft(const AbstractClient *client, int oldX, bool leftEdge) const;
     int packPositionRight(const AbstractClient *client, int oldX, bool rightEdge) const;
     int packPositionUp(const AbstractClient *client, int oldY, bool topEdge) const;
     int packPositionDown(const AbstractClient *client, int oldY, bool bottomEdge) const;
 
     void cancelDelayFocus();
     void requestDelayFocus(AbstractClient*);
 
     /**
      * updates the mouse position to track whether a focus follow mouse focus change was caused by
      * an actual mouse move
      * is esp. called on enter/motion events of inactive windows
      * since an active window doesn't receive mouse events, it must also be invoked if a (potentially)
      * active window might be moved/resize away from the cursor (causing a leave event)
      */
     void updateFocusMousePosition(const QPoint& pos);
     QPoint focusMousePosition() const;
 
     /**
      * Returns a client that is currently being moved or resized by the user.
      *
      * If none of clients is being moved or resized, @c null will be returned.
      */
     AbstractClient* moveResizeClient() {
         return movingClient;
     }
 
     /**
      * @returns Whether we have a Compositor and it is active (Scene created)
      */
     bool compositing() const;
 
     void registerEventFilter(X11EventFilter *filter);
     void unregisterEventFilter(X11EventFilter *filter);
 
     void markXStackingOrderAsDirty();
 
     void quickTileWindow(QuickTileMode mode);
 
     enum Direction {
         DirectionNorth,
         DirectionEast,
         DirectionSouth,
         DirectionWest
     };
     void switchWindow(Direction direction);
 
     ShortcutDialog *shortcutDialog() const {
         return client_keys_dialog;
     }
 
     /**
      * Adds the internal client to Workspace.
      *
      * This method will be called by InternalClient when it's mapped.
      *
      * @see internalClientAdded
      * @internal
      */
     void addInternalClient(InternalClient *client);
 
     /**
      * Removes the internal client from Workspace.
      *
      * This method is meant to be called only by InternalClient.
      *
      * @see internalClientRemoved
      * @internal
      */
     void removeInternalClient(InternalClient *client);
 
 public Q_SLOTS:
     void performWindowOperation(KWin::AbstractClient* c, Options::WindowOperation op);
     // Keybindings
     //void slotSwitchToWindow( int );
     void slotWindowToDesktop(uint i);
 
     //void slotWindowToListPosition( int );
     void slotSwitchToScreen();
     void slotWindowToScreen();
     void slotSwitchToNextScreen();
     void slotWindowToNextScreen();
     void slotSwitchToPrevScreen();
     void slotWindowToPrevScreen();
     void slotToggleShowDesktop();
 
     void slotWindowMaximize();
     void slotWindowMaximizeVertical();
     void slotWindowMaximizeHorizontal();
     void slotWindowMinimize();
     void slotWindowShade();
     void slotWindowRaise();
     void slotWindowLower();
     void slotWindowRaiseOrLower();
     void slotActivateAttentionWindow();
     void slotWindowPackLeft();
     void slotWindowPackRight();
     void slotWindowPackUp();
     void slotWindowPackDown();
     void slotWindowGrowHorizontal();
     void slotWindowGrowVertical();
     void slotWindowShrinkHorizontal();
     void slotWindowShrinkVertical();
 
     void slotIncreaseWindowOpacity();
     void slotLowerWindowOpacity();
 
     void slotWindowOperations();
     void slotWindowClose();
     void slotWindowMove();
     void slotWindowResize();
     void slotWindowAbove();
     void slotWindowBelow();
     void slotWindowOnAllDesktops();
     void slotWindowFullScreen();
     void slotWindowNoBorder();
 
     void slotWindowToNextDesktop();
     void slotWindowToPreviousDesktop();
     void slotWindowToDesktopRight();
     void slotWindowToDesktopLeft();
     void slotWindowToDesktopUp();
     void slotWindowToDesktopDown();
 
     void reconfigure();
     void slotReconfigure();
 
     void slotKillWindow();
 
     void slotSetupWindowShortcut();
     void setupWindowShortcutDone(bool);
 
     void updateClientArea();
 
 private Q_SLOTS:
     void desktopResized();
     void selectWmInputEventMask();
     void slotUpdateToolWindows();
     void delayFocus();
     void slotReloadConfig();
     void updateCurrentActivity(const QString &new_activity);
     // virtual desktop handling
     void slotDesktopCountChanged(uint previousCount, uint newCount);
     void slotCurrentDesktopChanged(uint oldDesktop, uint newDesktop);
 
     // session management
     void saveState(QSessionManager &sm);
 
 Q_SIGNALS:
     /**
      * Emitted after the Workspace has setup the complete initialization process.
      * This can be used to connect to for performing post-workspace initialization.
      */
     void workspaceInitialized();
 
     //Signals required for the scripting interface
     void desktopPresenceChanged(KWin::AbstractClient*, int);
     void currentDesktopChanged(int, KWin::AbstractClient*);
     void clientAdded(KWin::X11Client *);
     void clientRemoved(KWin::AbstractClient*);
     void clientActivated(KWin::AbstractClient*);
     void clientDemandsAttentionChanged(KWin::AbstractClient*, bool);
     void clientMinimizedChanged(KWin::AbstractClient*);
     void groupAdded(KWin::Group*);
     void unmanagedAdded(KWin::Unmanaged*);
     void unmanagedRemoved(KWin::Unmanaged*);
     void deletedRemoved(KWin::Deleted*);
     void configChanged();
     void showingDesktopChanged(bool showing);
     /**
      * This signels is emitted when ever the stacking order is change, ie. a window is risen
      * or lowered
      */
     void stackingOrderChanged();
 
     /**
      * This signal is emitted whenever an internal client is created.
      */
     void internalClientAdded(KWin::InternalClient *client);
 
     /**
      * This signal is emitted whenever an internal client gets removed.
      */
     void internalClientRemoved(KWin::InternalClient *client);
 
 private:
     void init();
     void initWithX11();
     void initShortcuts();
     template <typename Slot>
     void initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut,
                       Slot slot, const QVariant &data = QVariant());
     template <typename T, typename Slot>
     void initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut, T *receiver, Slot slot, const QVariant &data = QVariant());
     void setupWindowShortcut(AbstractClient* c);
     bool switchWindow(AbstractClient *c, Direction direction, QPoint curPos, int desktop);
 
     void propagateClients(bool propagate_new_clients);   // Called only from updateStackingOrder
     QList<Toplevel *> constrainedStackingOrder();
     void raiseClientWithinApplication(AbstractClient* c);
     void lowerClientWithinApplication(AbstractClient* c);
     bool allowFullClientRaising(const AbstractClient* c, xcb_timestamp_t timestamp);
     bool keepTransientAbove(const AbstractClient* mainwindow, const AbstractClient* transient);
     bool keepDeletedTransientAbove(const Toplevel *mainWindow, const Deleted *transient) const;
     void blockStackingUpdates(bool block);
     void updateToolWindows(bool also_hide);
     void fixPositionAfterCrash(xcb_window_t w, const xcb_get_geometry_reply_t *geom);
     void saveOldScreenSizes();
 
     /// This is the right way to create a new client
     X11Client *createClient(xcb_window_t w, bool is_mapped);
     void setupClientConnections(AbstractClient *client);
     void addClient(X11Client *c);
     Unmanaged* createUnmanaged(xcb_window_t w);
     void addUnmanaged(Unmanaged* c);
 
+    void addShellClient(AbstractClient *client);
+    void removeShellClient(AbstractClient *client);
+
     //---------------------------------------------------------------------
 
     void closeActivePopup();
     void updateClientArea(bool force);
     void resetClientAreas(uint desktopCount);
     void updateClientVisibilityOnDesktopChange(uint newDesktop);
     void activateClientOnNewDesktop(uint desktop);
     AbstractClient *findClientToActivateOnDesktop(uint desktop);
 
     QWidget* active_popup;
     AbstractClient* active_popup_client;
 
     int m_initialDesktop;
     void loadSessionInfo(const QString &key);
     void addSessionInfo(KConfigGroup &cg);
 
     QList<SessionInfo*> session;
 
     void updateXStackingOrder();
     void updateTabbox();
 
     AbstractClient* active_client;
     AbstractClient* last_active_client;
     AbstractClient* most_recently_raised; // Used ONLY by raiseOrLowerClient()
     AbstractClient* movingClient;
 
     // Delay(ed) window focus timer and client
     QTimer* delayFocusTimer;
     AbstractClient* delayfocus_client;
     QPoint focusMousePos;
 
     QList<X11Client *> clients;
     QList<AbstractClient*> m_allClients;
     QList<X11Client *> desktops;
     QList<Unmanaged *> unmanaged;
     QList<Deleted *> deleted;
     QList<InternalClient *> m_internalClients;
 
     QList<Toplevel *> unconstrained_stacking_order; // Topmost last
     QList<Toplevel *> stacking_order; // Topmost last
     QVector<xcb_window_t> manual_overlays; //Topmost last
     bool force_restacking;
     QList<Toplevel *> x_stacking; // From XQueryTree()
     std::unique_ptr<Xcb::Tree> m_xStackingQueryTree;
     bool m_xStackingDirty = false;
     QList<AbstractClient*> should_get_focus; // Last is most recent
     QList<AbstractClient*> attention_chain;
 
     bool showing_desktop;
 
     QList<Group *> groups;
 
     bool was_user_interaction;
     QScopedPointer<X11EventFilter> m_wasUserInteractionFilter;
 
     int session_active_client;
     int session_desktop;
 
     int block_focus;
 
     /**
      * Holds the menu containing the user actions which is shown
      * on e.g. right click the window decoration.
      */
     UserActionsMenu *m_userActionsMenu;
 
     void modalActionsSwitch(bool enabled);
 
     ShortcutDialog* client_keys_dialog;
     AbstractClient* client_keys_client;
     bool global_shortcuts_disabled_for_client;
 
     // Timer to collect requests for 'reconfigure'
     QTimer reconfigureTimer;
 
     QTimer updateToolWindowsTimer;
 
     static Workspace* _self;
 
     bool workspaceInit;
 
     KStartupInfo* startup;
 
     QVector<QRect> workarea; // Array of workareas for virtual desktops
     // Array of restricted areas that window cannot be moved into
     QVector<StrutRects> restrictedmovearea;
     // Array of the previous restricted areas that window cannot be moved into
     QVector<StrutRects> oldrestrictedmovearea;
     QVector< QVector<QRect> > screenarea; // Array of workareas per xinerama screen for all virtual desktops
     QVector< QRect > oldscreensizes; // array of previous sizes of xinerama screens
     QSize olddisplaysize; // previous sizes od displayWidth()/displayHeight()
 
     int set_active_client_recursion;
     int block_stacking_updates; // When > 0, stacking updates are temporarily disabled
     bool blocked_propagating_new_clients; // Propagate also new clients after enabling stacking updates?
     QScopedPointer<Xcb::Window> m_nullFocus;
     friend class StackingUpdatesBlocker;
 
     QScopedPointer<KillWindow> m_windowKiller;
 
     QList<X11EventFilter *> m_eventFilters;
     QList<X11EventFilter *> m_genericEventFilters;
     QScopedPointer<X11EventFilter> m_movingClientFilter;
 
     SessionManager *m_sessionManager;
 private:
     friend bool performTransiencyCheck();
     friend Workspace *workspace();
 };
 
 /**
  * Helper for Workspace::blockStackingUpdates() being called in pairs (True/false)
  */
 class StackingUpdatesBlocker
 {
 public:
     explicit StackingUpdatesBlocker(Workspace* w)
         : ws(w) {
         ws->blockStackingUpdates(true);
     }
     ~StackingUpdatesBlocker() {
         ws->blockStackingUpdates(false);
     }
 
 private:
     Workspace* ws;
 };
 
 class ColorMapper : public QObject
 {
     Q_OBJECT
 public:
     ColorMapper(QObject *parent);
     ~ColorMapper() override;
 public Q_SLOTS:
     void update();
 private:
     xcb_colormap_t m_default;
     xcb_colormap_t m_installed;
 };
 
 //---------------------------------------------------------
 // Unsorted
 
 inline bool Workspace::initializing() const
 {
     return workspaceInit;
 }
 
 inline AbstractClient *Workspace::activeClient() const
 {
     return active_client;
 }
 
 inline AbstractClient *Workspace::mostRecentlyActivatedClient() const
 {
     return should_get_focus.count() > 0 ? should_get_focus.last() : active_client;
 }
 
 inline void Workspace::addGroup(Group* group)
 {
     emit groupAdded(group);
     groups.append(group);
 }
 
 inline void Workspace::removeGroup(Group* group)
 {
     groups.removeAll(group);
 }
 
 inline const QList<Toplevel *> &Workspace::stackingOrder() const
 {
     // TODO: Q_ASSERT( block_stacking_updates == 0 );
     return stacking_order;
 }
 
 inline bool Workspace::wasUserInteraction() const
 {
     return was_user_interaction;
 }
 
 inline SessionManager *Workspace::sessionManager() const
 {
     return m_sessionManager;
 }
 
 inline bool Workspace::showingDesktop() const
 {
     return showing_desktop;
 }
 
 inline bool Workspace::globalShortcutsDisabled() const
 {
     return global_shortcuts_disabled_for_client;
 }
 
 inline void Workspace::forceRestacking()
 {
     force_restacking = true;
     StackingUpdatesBlocker blocker(this);   // Do restacking if not blocked
 }
 
 inline void Workspace::updateFocusMousePosition(const QPoint& pos)
 {
     focusMousePos = pos;
 }
 
 inline QPoint Workspace::focusMousePosition() const
 {
     return focusMousePos;
 }
 
 inline
 void Workspace::forEachClient(std::function< void (X11Client *) > func)
 {
     std::for_each(clients.constBegin(), clients.constEnd(), func);
     std::for_each(desktops.constBegin(), desktops.constEnd(), func);
 }
 
 inline
 void Workspace::forEachUnmanaged(std::function< void (Unmanaged*) > func)
 {
     std::for_each(unmanaged.constBegin(), unmanaged.constEnd(), func);
 }
 
 inline bool Workspace::hasClient(const X11Client *c)
 {
     return findClient([c](const X11Client *test) {
         return test == c;
     });
 }
 
 inline Workspace *workspace()
 {
     return Workspace::_self;
 }
 
 } // namespace
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Workspace::ActivityFlags)
 
 #endif
diff --git a/xdgshellclient.cpp b/xdgshellclient.cpp
index 4118b91b7..e1839b3da 100644
--- a/xdgshellclient.cpp
+++ b/xdgshellclient.cpp
@@ -1,2080 +1,2074 @@
 /********************************************************************
  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>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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 "xdgshellclient.h"
 #include "cursor.h"
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationbridge.h"
 #include "deleted.h"
 #include "placement.h"
 #include "screenedge.h"
 #include "screens.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KWayland/Server/appmenu_interface.h>
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/clientconnection.h>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/plasmashell_interface.h>
 #include <KWayland/Server/plasmawindowmanagement_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/surface_interface.h>
 #include <KWayland/Server/xdgdecoration_interface.h>
 
 #include <QFileInfo>
 
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <csignal>
 
 Q_DECLARE_METATYPE(NET::WindowType)
 
 using namespace KWayland::Server;
 
 namespace KWin
 {
 
 XdgShellClient::XdgShellClient(XdgShellSurfaceInterface *surface)
     : AbstractClient()
     , m_xdgShellToplevel(surface)
     , m_xdgShellPopup(nullptr)
 {
     setSurface(surface->surface());
     init();
 }
 
 XdgShellClient::XdgShellClient(XdgShellPopupInterface *surface)
     : AbstractClient()
     , m_xdgShellToplevel(nullptr)
     , m_xdgShellPopup(surface)
 {
     setSurface(surface->surface());
     init();
 }
 
 XdgShellClient::~XdgShellClient() = default;
 
 void XdgShellClient::init()
 {
     m_requestGeometryBlockCounter++;
 
     connect(this, &XdgShellClient::desktopFileNameChanged, this, &XdgShellClient::updateIcon);
     createWindowId();
     setupCompositing();
     updateIcon();
 
     // TODO: Initialize with null rect.
     m_frameGeometry = QRect(0, 0, -1, -1);
     m_windowGeometry = QRect(0, 0, -1, -1);
 
     if (waylandServer()->inputMethodConnection() == surface()->client()) {
         m_windowType = NET::OnScreenDisplay;
     }
 
     connect(surface(), &SurfaceInterface::unmapped, this, &XdgShellClient::unmap);
     connect(surface(), &SurfaceInterface::unbound, this, &XdgShellClient::destroyClient);
     connect(surface(), &SurfaceInterface::destroyed, this, &XdgShellClient::destroyClient);
 
     if (m_xdgShellToplevel) {
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::destroyed, this, &XdgShellClient::destroyClient);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::configureAcknowledged, this, &XdgShellClient::handleConfigureAcknowledged);
 
         m_caption = m_xdgShellToplevel->title().simplified();
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::titleChanged, this, &XdgShellClient::handleWindowTitleChanged);
         QTimer::singleShot(0, this, &XdgShellClient::updateCaption);
 
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::moveRequested, this, &XdgShellClient::handleMoveRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::resizeRequested, this, &XdgShellClient::handleResizeRequested);
 
         // Determine the resource name, this is inspired from ICCCM 4.1.2.5
         // the binary name of the invoked client.
         QFileInfo info{m_xdgShellToplevel->client()->executablePath()};
         QByteArray resourceName;
         if (info.exists()) {
             resourceName = info.fileName().toUtf8();
         }
         setResourceClass(resourceName, m_xdgShellToplevel->windowClass());
         setDesktopFileName(m_xdgShellToplevel->windowClass());
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowClassChanged, this, &XdgShellClient::handleWindowClassChanged);
 
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::minimizeRequested, this, &XdgShellClient::handleMinimizeRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::maximizedChanged, this, &XdgShellClient::handleMaximizeRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::fullscreenChanged, this, &XdgShellClient::handleFullScreenRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowMenuRequested, this, &XdgShellClient::handleWindowMenuRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::transientForChanged, this, &XdgShellClient::handleTransientForChanged);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowGeometryChanged, this, &XdgShellClient::handleWindowGeometryChanged);
 
         auto global = static_cast<XdgShellInterface *>(m_xdgShellToplevel->global());
         connect(global, &XdgShellInterface::pingDelayed, this, &XdgShellClient::handlePingDelayed);
         connect(global, &XdgShellInterface::pingTimeout, this, &XdgShellClient::handlePingTimeout);
         connect(global, &XdgShellInterface::pongReceived, this, &XdgShellClient::handlePongReceived);
 
         auto configure = [this] {
             if (m_closing) {
                 return;
             }
             if (m_requestGeometryBlockCounter != 0 || areGeometryUpdatesBlocked()) {
                 return;
             }
             m_xdgShellToplevel->configure(xdgSurfaceStates(), m_requestedClientSize);
         };
         connect(this, &AbstractClient::activeChanged, this, configure);
         connect(this, &AbstractClient::clientStartUserMovedResized, this, configure);
         connect(this, &AbstractClient::clientFinishUserMovedResized, this, configure);
 
         connect(this, &XdgShellClient::frameGeometryChanged, this, &XdgShellClient::updateClientOutputs);
         connect(screens(), &Screens::changed, this, &XdgShellClient::updateClientOutputs);
     } else if (m_xdgShellPopup) {
         connect(m_xdgShellPopup, &XdgShellPopupInterface::configureAcknowledged, this, &XdgShellClient::handleConfigureAcknowledged);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::grabRequested, this, &XdgShellClient::handleGrabRequested);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::destroyed, this, &XdgShellClient::destroyClient);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::windowGeometryChanged, this, &XdgShellClient::handleWindowGeometryChanged);
     }
 
     // set initial desktop
     setDesktop(VirtualDesktopManager::self()->current());
 
     // setup shadow integration
     updateShadow();
     connect(surface(), &SurfaceInterface::shadowChanged, this, &Toplevel::updateShadow);
 
     connect(waylandServer(), &WaylandServer::foreignTransientChanged, this, [this](KWayland::Server::SurfaceInterface *child) {
         if (child == surface()) {
             handleTransientForChanged();
         }
     });
     handleTransientForChanged();
 
     AbstractClient::updateColorScheme(QString());
 
     connect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::finishInit);
 }
 
 void XdgShellClient::finishInit()
 {
     disconnect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::finishInit);
 
     connect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::handleCommitted);
 
     bool needsPlacement = !isInitialPositionSet();
 
     if (supportsWindowRules()) {
         setupWindowRules(false);
 
         const QRect originalGeometry = frameGeometry();
         const QRect ruledGeometry = rules()->checkGeometry(originalGeometry, true);
         if (originalGeometry != ruledGeometry) {
             setFrameGeometry(ruledGeometry);
         }
 
         maximize(rules()->checkMaximize(maximizeMode(), true));
 
         setDesktop(rules()->checkDesktop(desktop(), true));
         setDesktopFileName(rules()->checkDesktopFile(desktopFileName(), true).toUtf8());
         if (rules()->checkMinimize(isMinimized(), true)) {
             minimize(true); // No animation.
         }
         setSkipTaskbar(rules()->checkSkipTaskbar(skipTaskbar(), true));
         setSkipPager(rules()->checkSkipPager(skipPager(), true));
         setSkipSwitcher(rules()->checkSkipSwitcher(skipSwitcher(), true));
         setKeepAbove(rules()->checkKeepAbove(keepAbove(), true));
         setKeepBelow(rules()->checkKeepBelow(keepBelow(), true));
         setShortcut(rules()->checkShortcut(shortcut().toString(), true));
         updateColorScheme();
 
         // Don't place the client if its position is set by a rule.
         if (rules()->checkPosition(invalidPoint, true) != invalidPoint) {
             needsPlacement = false;
         }
 
         // Don't place the client if the maximize state is set by a rule.
         if (requestedMaximizeMode() != MaximizeRestore) {
             needsPlacement = false;
         }
 
         discardTemporaryRules();
         RuleBook::self()->discardUsed(this, false); // Remove Apply Now rules.
         updateWindowRules(Rules::All);
     }
 
     if (isFullScreen()) {
         needsPlacement = false;
     }
 
     if (needsPlacement) {
         const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
         placeIn(area);
     }
 
     m_requestGeometryBlockCounter--;
     if (m_requestGeometryBlockCounter == 0) {
         requestGeometry(m_blockedRequestGeometry);
     }
 
     m_isInitialized = true;
 }
 
 void XdgShellClient::destroyClient()
 {
     m_closing = true;
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox->isDisplayed() && tabBox->currentClient() == this) {
         tabBox->nextPrev(true);
     }
 #endif
     if (isMoveResize()) {
         leaveMoveResize();
     }
 
     // Replace ShellClient with an instance of Deleted in the stacking order.
     Deleted *deleted = Deleted::create(this);
     emit windowClosed(this, deleted);
 
     // Remove Force Temporarily rules.
     RuleBook::self()->discardUsed(this, true);
 
     destroyWindowManagementInterface();
     destroyDecoration();
 
     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);
 
     deleted->unrefWindow();
 
     m_xdgShellToplevel = nullptr;
     m_xdgShellPopup = nullptr;
     deleteClient(this);
 }
 
 void XdgShellClient::deleteClient(XdgShellClient *c)
 {
     delete c;
 }
 
 QRect XdgShellClient::inputGeometry() const
 {
     if (isDecorated()) {
         return AbstractClient::inputGeometry();
     }
     // TODO: What about sub-surfaces sticking outside the main surface?
     return m_bufferGeometry;
 }
 
 QRect XdgShellClient::bufferGeometry() const
 {
     return m_bufferGeometry;
 }
 
 QStringList XdgShellClient::activities() const
 {
     // TODO: implement
     return QStringList();
 }
 
 QPoint XdgShellClient::clientContentPos() const
 {
     return -1 * clientPos();
 }
 
 static QRect subSurfaceTreeRect(const SurfaceInterface *surface, const QPoint &position = QPoint())
 {
     QRect rect(position, surface->size());
 
     const QList<QPointer<SubSurfaceInterface>> subSurfaces = surface->childSubSurfaces();
     for (const QPointer<SubSurfaceInterface> &subSurface : subSurfaces) {
         if (Q_UNLIKELY(!subSurface)) {
             continue;
         }
         const SurfaceInterface *child = subSurface->surface();
         if (Q_UNLIKELY(!child)) {
             continue;
         }
         rect |= subSurfaceTreeRect(child, position + subSurface->position());
     }
 
     return rect;
 }
 
 QSize XdgShellClient::clientSize() const
 {
     const QRect boundingRect = subSurfaceTreeRect(surface());
     return m_windowGeometry.size().boundedTo(boundingRect.size());
 }
 
 QSize XdgShellClient::minSize() const
 {
     if (m_xdgShellToplevel) {
         return rules()->checkMinSize(m_xdgShellToplevel->minimumSize());
     }
     return QSize(0, 0);
 }
 
 QSize XdgShellClient::maxSize() const
 {
     if (m_xdgShellToplevel) {
         return rules()->checkMaxSize(m_xdgShellToplevel->maximumSize());
     }
     return QSize(INT_MAX, INT_MAX);
 }
 
 void XdgShellClient::debug(QDebug &stream) const
 {
     stream.nospace();
     stream << "\'XdgShellClient:" << surface() << ";WMCLASS:" << resourceClass() << ":"
            << resourceName() << ";Caption:" << caption() << "\'";
 }
 
 bool XdgShellClient::belongsToDesktop() const
 {
     const auto clients = waylandServer()->clients();
 
     return std::any_of(clients.constBegin(), clients.constEnd(),
-        [this](const XdgShellClient *client) {
+        [this](const AbstractClient *client) {
             if (belongsToSameApplication(client, SameApplicationChecks())) {
                 return client->isDesktop();
             }
             return false;
         }
     );
 }
 
 Layer XdgShellClient::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 XdgShellClient::transparentRect() const
 {
     // TODO: implement
     return QRect();
 }
 
 NET::WindowType XdgShellClient::windowType(bool direct, int supported_types) const
 {
     // TODO: implement
     Q_UNUSED(direct)
     Q_UNUSED(supported_types)
     return m_windowType;
 }
 
 double XdgShellClient::opacity() const
 {
     return m_opacity;
 }
 
 void XdgShellClient::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 XdgShellClient::addDamage(const QRegion &damage)
 {
     const int offsetX = m_bufferGeometry.x() - frameGeometry().x();
     const int offsetY = m_bufferGeometry.y() - frameGeometry().y();
     repaints_region += damage.translated(offsetX, offsetY);
 
     Toplevel::addDamage(damage);
 }
 
 void XdgShellClient::markAsMapped()
 {
     if (!m_unmapped) {
         return;
     }
 
     m_unmapped = false;
     if (!ready_for_painting) {
         setReadyForPainting();
     } else {
         addRepaintFull();
         emit windowShown(this);
     }
     if (shouldExposeToWindowManagement()) {
         setupWindowManagementInterface();
     }
     updateShowOnScreenEdge();
 }
 
 void XdgShellClient::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::updateShadow);
         connect(decoration, &KDecoration2::Decoration::bordersChanged, this,
             [this]() {
                 GeometryUpdatesBlocker blocker(this);
                 RequestGeometryBlocker requestBlocker(this);
                 const QRect oldGeometry = frameGeometry();
                 if (!isShade()) {
                     checkWorkspacePosition(oldGeometry);
                 }
                 emit geometryShapeChanged(this, oldGeometry);
             }
         );
     }
     setDecoration(decoration);
     // TODO: ensure the new geometry still fits into the client area (e.g. maximized windows)
     doSetGeometry(QRect(oldGeom.topLeft(), m_windowGeometry.size() + QSize(borderLeft() + borderRight(), borderBottom() + borderTop())));
 
     emit geometryShapeChanged(this, oldGeom);
 }
 
 void XdgShellClient::updateDecoration(bool check_workspace_pos, bool force)
 {
     if (!force &&
             ((!isDecorated() && noBorder()) || (isDecorated() && !noBorder())))
         return;
     QRect oldgeom = frameGeometry();
     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() || m_userNoBorder ? XdgDecorationInterface::Mode::ServerSide: XdgDecorationInterface::Mode::ClientSide;
         m_xdgDecoration->configure(mode);
         if (m_requestGeometryBlockCounter == 0) {
             m_xdgShellToplevel->configure(xdgSurfaceStates(), m_requestedClientSize);
         }
     }
     updateShadow();
     if (check_workspace_pos)
         checkWorkspacePosition(oldgeom, -2, oldClientGeom);
     blockGeometryUpdates(false);
 }
 
 void XdgShellClient::setFrameGeometry(int x, int y, int w, int h, ForceGeometry_t force)
 {
     const QRect newGeometry = rules()->checkGeometry(QRect(x, y, w, h));
 
     if (areGeometryUpdatesBlocked()) {
         // when the GeometryUpdateBlocker exits the current geom is passed to setGeometry
         // thus we need to set it here.
         m_frameGeometry = newGeometry;
         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
         m_frameGeometry = frameGeometryBeforeUpdateBlocking();
     }
 
     const QSize requestedClientSize = newGeometry.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
 
     if (requestedClientSize == m_windowGeometry.size() &&
         (m_requestedClientSize.isEmpty() || requestedClientSize == m_requestedClientSize)) {
         // size didn't change, and we don't need to explicitly request a new size
         doSetGeometry(newGeometry);
         updateMaximizeMode(m_requestedMaximizeMode);
     } else {
         // size did change, Client needs to provide a new buffer
         requestGeometry(newGeometry);
     }
 }
 
 QRect XdgShellClient::determineBufferGeometry() const
 {
     // Offset of the main surface relative to the frame rect.
     const int offsetX = borderLeft() - m_windowGeometry.left();
     const int offsetY = borderTop() - m_windowGeometry.top();
 
     QRect bufferGeometry;
     bufferGeometry.setX(x() + offsetX);
     bufferGeometry.setY(y() + offsetY);
     bufferGeometry.setSize(surface()->size());
 
     return bufferGeometry;
 }
 
 void XdgShellClient::doSetGeometry(const QRect &rect)
 {
     bool frameGeometryIsChanged = false;
     bool bufferGeometryIsChanged = false;
 
     if (m_frameGeometry != rect) {
         m_frameGeometry = rect;
         frameGeometryIsChanged = true;
     }
 
     const QRect bufferGeometry = determineBufferGeometry();
     if (m_bufferGeometry != bufferGeometry) {
         m_bufferGeometry = bufferGeometry;
         bufferGeometryIsChanged = true;
     }
 
     if (!frameGeometryIsChanged && !bufferGeometryIsChanged) {
         return;
     }
 
     if (m_unmapped && geometryRestore().isEmpty() && !m_frameGeometry.isEmpty()) {
         // use first valid geometry as restore geometry
         setGeometryRestore(m_frameGeometry);
     }
 
     if (frameGeometryIsChanged) {
         if (hasStrut()) {
             workspace()->updateClientArea();
         }
         updateWindowRules(Rules::Position | Rules::Size);
         emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     }
 
     emit geometryShapeChanged(this, frameGeometryBeforeUpdateBlocking());
 
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 
     if (isResize()) {
         performMoveResize();
     }
 }
 
 void XdgShellClient::doMove(int x, int y)
 {
     Q_UNUSED(x)
     Q_UNUSED(y)
     m_bufferGeometry = determineBufferGeometry();
 }
 
 QByteArray XdgShellClient::windowRole() const
 {
     return QByteArray();
 }
 
 bool XdgShellClient::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 XdgShellClient::blockActivityUpdates(bool b)
 {
     Q_UNUSED(b)
 }
 
 QString XdgShellClient::captionNormal() const
 {
     return m_caption;
 }
 
 QString XdgShellClient::captionSuffix() const
 {
     return m_captionSuffix;
 }
 
 void XdgShellClient::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 XdgShellClient::closeWindow()
 {
     if (m_xdgShellToplevel && isCloseable()) {
         m_xdgShellToplevel->close();
         ping(PingReason::CloseWindow);
     }
 }
 
 AbstractClient *XdgShellClient::findModal(bool allow_itself)
 {
     Q_UNUSED(allow_itself)
     return nullptr;
 }
 
 bool XdgShellClient::isCloseable() const
 {
     if (m_windowType == NET::Desktop || m_windowType == NET::Dock) {
         return false;
     }
     if (m_xdgShellToplevel) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::isFullScreen() const
 {
     return m_fullScreen;
 }
 
 bool XdgShellClient::isMaximizable() const
 {
     if (!isResizable()) {
         return false;
     }
     if (rules()->checkMaximize(MaximizeRestore) != MaximizeRestore || rules()->checkMaximize(MaximizeFull) != MaximizeFull) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isMinimizable() const
 {
     if (!rules()->checkMinimize(true)) {
         return false;
     }
     return (!m_plasmaShellSurface || m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal);
 }
 
 bool XdgShellClient::isMovable() const
 {
     if (isFullScreen()) {
         return false;
     }
     if (rules()->checkPosition(invalidPoint) != invalidPoint) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isMovableAcrossScreens() const
 {
     if (rules()->checkPosition(invalidPoint) != invalidPoint) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isResizable() const
 {
     if (isFullScreen()) {
         return false;
     }
     if (rules()->checkSize(QSize()).isValid()) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isShown(bool shaded_is_shown) const
 {
     Q_UNUSED(shaded_is_shown)
     return !m_closing && !m_unmapped && !isMinimized() && !m_hidden;
 }
 
 bool XdgShellClient::isHiddenInternal() const
 {
     return m_unmapped || m_hidden;
 }
 
 void XdgShellClient::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 XdgShellClient::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 = frameGeometry();
 
     // '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);
     }
 
     m_requestedMaximizeMode = rules()->checkMaximize(m_requestedMaximizeMode);
     if (!adjust && m_requestedMaximizeMode == oldMode) {
         return;
     }
 
     StackingUpdatesBlocker blocker(workspace());
     RequestGeometryBlocker geometryBlocker(this);
 
     // 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(geometryRestore().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
         }
     }
 
     if (m_requestedMaximizeMode == MaximizeFull) {
         setGeometryRestore(oldGeometry);
         // TODO: Client has more checks
         if (options->electricBorderMaximize()) {
             updateQuickTileMode(QuickTileFlag::Maximize);
         } else {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
         setFrameGeometry(workspace()->clientArea(MaximizeArea, this));
         workspace()->raiseClient(this);
     } else {
         if (m_requestedMaximizeMode == MaximizeRestore) {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
 
         if (geometryRestore().isValid()) {
             setFrameGeometry(geometryRestore());
         } else {
             setFrameGeometry(workspace()->clientArea(PlacementArea, this));
         }
     }
 }
 
 MaximizeMode XdgShellClient::maximizeMode() const
 {
     return m_maximizeMode;
 }
 
 MaximizeMode XdgShellClient::requestedMaximizeMode() const
 {
     return m_requestedMaximizeMode;
 }
 
 bool XdgShellClient::noBorder() const
 {
     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;
 }
 
 bool XdgShellClient::isFullScreenable() const
 {
     if (!rules()->checkFullScreen(true)) {
         return false;
     }
     return !isSpecialWindow();
 }
 
 void XdgShellClient::setFullScreen(bool set, bool user)
 {
     set = rules()->checkFullScreen(set);
 
     const bool wasFullscreen = isFullScreen();
     if (wasFullscreen == set) {
         return;
     }
     if (isSpecialWindow()) {
         return;
     }
     if (user && !userCanSetFullScreen()) {
         return;
     }
 
     if (wasFullscreen) {
         workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
     } else {
         m_geomFsRestore = frameGeometry();
     }
     m_fullScreen = set;
 
     if (set) {
         workspace()->raiseClient(this);
     }
     RequestGeometryBlocker requestBlocker(this);
     StackingUpdatesBlocker blocker1(workspace());
     GeometryUpdatesBlocker blocker2(this);
 
     workspace()->updateClientLayer(this);   // active fullscreens get different layer
     updateDecoration(false, false);
 
     if (set) {
         setFrameGeometry(workspace()->clientArea(FullScreenArea, this));
     } else {
         if (m_geomFsRestore.isValid()) {
             int currentScreen = screen();
             setFrameGeometry(QRect(m_geomFsRestore.topLeft(), constrainFrameSize(m_geomFsRestore.size())));
             if( currentScreen != screen())
                 workspace()->sendClientToScreen( this, currentScreen );
         } else {
             // this can happen when the window was first shown already fullscreen,
             // so let the client set the size by itself
             setFrameGeometry(QRect(workspace()->clientArea(PlacementArea, this).topLeft(), QSize(0, 0)));
         }
     }
 
     updateWindowRules(Rules::Fullscreen|Rules::Position|Rules::Size);
     emit fullScreenChanged();
 }
 
 void XdgShellClient::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 XdgShellClient::setOnAllActivities(bool set)
 {
     Q_UNUSED(set)
 }
 
 void XdgShellClient::takeFocus()
 {
     if (rules()->checkAcceptFocus(wantsInput())) {
         if (m_xdgShellToplevel) {
             ping(PingReason::FocusWindow);
         }
         setActive(true);
     }
 
     if (!keepAbove() && !isOnScreenDisplay() && !belongsToDesktop()) {
         workspace()->setShowingDesktop(false);
     }
 }
 
 void XdgShellClient::doSetActive()
 {
     if (!isActive()) {
         return;
     }
     StackingUpdatesBlocker blocker(workspace());
     workspace()->focusToNull();
 }
 
 bool XdgShellClient::userCanSetFullScreen() const
 {
     if (m_xdgShellToplevel) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::userCanSetNoBorder() const
 {
     if (m_serverDecoration && m_serverDecoration->mode() == ServerSideDecorationManagerInterface::Mode::Server) {
         return !isFullScreen() && !isShade();
     }
     if (m_xdgDecoration && m_xdgDecoration->requestedMode() != XdgDecorationInterface::Mode::ClientSide) {
         return !isFullScreen() && !isShade();
     }
     return false;
 }
 
 bool XdgShellClient::wantsInput() const
 {
     return rules()->checkAcceptFocus(acceptsFocus());
 }
 
 bool XdgShellClient::acceptsFocus() const
 {
     if (waylandServer()->inputMethodConnection() == surface()->client()) {
         return false;
     }
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::OnScreenDisplay ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::ToolTip) {
             return false;
         }
 
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Notification ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::CriticalNotification) {
             return m_plasmaShellSurface->panelTakesFocus();
         }
     }
     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_xdgShellToplevel) {
         // TODO: proper
         return true;
     }
     return false;
 }
 
 void XdgShellClient::createWindowId()
 {
     m_windowId = waylandServer()->createWindowId(surface());
 }
 
 pid_t XdgShellClient::pid() const
 {
     return surface()->client()->processId();
 }
 
 bool XdgShellClient::isLockScreen() const
 {
     return surface()->client() == waylandServer()->screenLockerClientConnection();
 }
 
 bool XdgShellClient::isInputMethod() const
 {
     return surface()->client() == waylandServer()->inputMethodConnection();
 }
 
 void XdgShellClient::requestGeometry(const QRect &rect)
 {
     if (m_requestGeometryBlockCounter != 0) {
         m_blockedRequestGeometry = rect;
         return;
     }
 
     QSize size;
     if (rect.isValid()) {
         size = rect.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
     } else {
         size = QSize(0, 0);
     }
     m_requestedClientSize = size;
 
     quint64 serialId = 0;
 
     if (m_xdgShellToplevel) {
         serialId = m_xdgShellToplevel->configure(xdgSurfaceStates(), size);
     }
     if (m_xdgShellPopup) {
         auto parent = transientFor();
         if (parent) {
             const QPoint globalClientContentPos = parent->frameGeometry().topLeft() + parent->clientPos();
             const QPoint relativeOffset = rect.topLeft() - globalClientContentPos;
             serialId = m_xdgShellPopup->configure(QRect(relativeOffset, size));
         }
     }
 
     if (rect.isValid()) { //if there's no requested size, then there's implicity no positional information worth using
         PendingConfigureRequest configureRequest;
         configureRequest.serialId = serialId;
         configureRequest.positionAfterResize = rect.topLeft();
         configureRequest.maximizeMode = m_requestedMaximizeMode;
         m_pendingConfigureRequests.append(configureRequest);
     }
 
     m_blockedRequestGeometry = QRect();
 }
 
 void XdgShellClient::updatePendingGeometry()
 {
     QPoint position = pos();
     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(frameGeometry());
             }
             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
     }
     QRect geometry = QRect(position, adjustedSize());
     if (isMove()) {
         geometry = adjustMoveGeometry(geometry);
     }
     if (isResize()) {
         geometry = adjustResizeGeometry(geometry);
     }
     doSetGeometry(geometry);
     updateMaximizeMode(maximizeMode);
 }
 
 void XdgShellClient::handleConfigureAcknowledged(quint32 serial)
 {
     m_lastAckedConfigureRequest = serial;
 }
 
 void XdgShellClient::handleTransientForChanged()
 {
     SurfaceInterface *transientSurface = nullptr;
     if (m_xdgShellToplevel) {
         if (auto transient = m_xdgShellToplevel->transientFor().data()) {
             transientSurface = transient->surface();
         }
     }
     if (m_xdgShellPopup) {
         transientSurface = m_xdgShellPopup->transientFor().data();
     }
     if (!transientSurface) {
         transientSurface = waylandServer()->findForeignTransientForSurface(surface());
     }
-    XdgShellClient *transientClient = waylandServer()->findClient(transientSurface);
+    AbstractClient *transientClient = waylandServer()->findClient(transientSurface);
     if (transientClient != transientFor()) {
         // Remove from main client.
         if (transientFor()) {
             transientFor()->removeTransient(this);
         }
         setTransientFor(transientClient);
         if (transientClient) {
             transientClient->addTransient(this);
         }
     }
     m_transient = (transientSurface != nullptr);
 }
 
 void XdgShellClient::handleWindowClassChanged(const QByteArray &windowClass)
 {
     setResourceClass(resourceName(), windowClass);
     if (m_isInitialized && supportsWindowRules()) {
         setupWindowRules(true);
         applyWindowRules();
     }
     setDesktopFileName(windowClass);
 }
 
 void XdgShellClient::handleWindowGeometryChanged(const QRect &windowGeometry)
 {
     m_windowGeometry = windowGeometry;
     m_hasWindowGeometry = true;
 }
 
 void XdgShellClient::handleWindowTitleChanged(const QString &title)
 {
     const QString oldSuffix = m_captionSuffix;
     m_caption = title.simplified();
     updateCaption();
     if (m_captionSuffix == oldSuffix) {
         // Don't emit caption change twice it already got emitted by the changing suffix.
         emit captionChanged();
     }
 }
 
 void XdgShellClient::handleMoveRequested(SeatInterface *seat, quint32 serial)
 {
     // FIXME: Check the seat and serial.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     performMouseCommand(Options::MouseMove, Cursor::pos());
 }
 
 void XdgShellClient::handleResizeRequested(SeatInterface *seat, quint32 serial, Qt::Edges edges)
 {
     // FIXME: 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 position = PositionCenter;
         if (edges.testFlag(Qt::TopEdge)) {
             position = PositionTop;
         } else if (edges.testFlag(Qt::BottomEdge)) {
             position = PositionBottom;
         }
         if (edges.testFlag(Qt::LeftEdge)) {
             position = Position(position | PositionLeft);
         } else if (edges.testFlag(Qt::RightEdge)) {
             position = Position(position | PositionRight);
         }
         return position;
     };
     setMoveResizePointerMode(toPosition());
     if (!startMoveResize()) {
         setMoveResizePointerButtonDown(false);
     }
     updateCursor();
 }
 
 void XdgShellClient::handleMinimizeRequested()
 {
     performMouseCommand(Options::MouseMinimize, Cursor::pos());
 }
 
 void XdgShellClient::handleMaximizeRequested(bool maximized)
 {
     // If the maximized state of the client hasn't been changed due to a window
     // rule or because the requested state is the same as the current, then the
     // compositor still has to send a configure event.
     RequestGeometryBlocker blocker(this);
 
     maximize(maximized ? MaximizeFull : MaximizeRestore);
 }
 
 void XdgShellClient::handleFullScreenRequested(bool fullScreen, OutputInterface *output)
 {
     // FIXME: Consider output as well.
     Q_UNUSED(output);
     setFullScreen(fullScreen, false);
 }
 
 void XdgShellClient::handleWindowMenuRequested(SeatInterface *seat, quint32 serial, const QPoint &surfacePos)
 {
     // FIXME: Check the seat and serial.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     performMouseCommand(Options::MouseOperationsMenu, pos() + surfacePos);
 }
 
 void XdgShellClient::handleGrabRequested(SeatInterface *seat, quint32 serial)
 {
     // FIXME: Check the seat and serial as well whether the parent had focus.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     m_hasPopupGrab = true;
 }
 
 void XdgShellClient::handlePingDelayed(quint32 serial)
 {
     auto it = m_pingSerials.find(serial);
     if (it != m_pingSerials.end()) {
         qCDebug(KWIN_CORE) << "First ping timeout:" << caption();
         setUnresponsive(true);
     }
 }
 
 void XdgShellClient::handlePingTimeout(quint32 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);
     }
 }
 
 void XdgShellClient::handlePongReceived(quint32 serial)
 {
     auto it = m_pingSerials.find(serial);
     if (it != m_pingSerials.end()) {
         setUnresponsive(false);
         m_pingSerials.erase(it);
     }
 }
 
 void XdgShellClient::handleCommitted()
 {
     if (!surface()->buffer()) {
         return;
     }
 
     if (!m_hasWindowGeometry) {
         m_windowGeometry = subSurfaceTreeRect(surface());
     }
 
     updatePendingGeometry();
 
     setDepth((surface()->buffer()->hasAlphaChannel() && !isDesktop()) ? 32 : 24);
     markAsMapped();
 }
 
 void XdgShellClient::resizeWithChecks(int w, int h, ForceGeometry_t force)
 {
     const 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();
     }
     setFrameGeometry(x(), y(), w, h, force);
 }
 
 void XdgShellClient::unmap()
 {
     m_unmapped = true;
     if (isMoveResize()) {
         leaveMoveResize();
     }
     m_requestedClientSize = QSize(0, 0);
     destroyWindowManagementInterface();
     if (Workspace::self()) {
         addWorkspaceRepaint(visibleRect());
         workspace()->clientHidden(this);
     }
     emit windowHidden(this);
 }
 
 void XdgShellClient::installPlasmaShellSurface(PlasmaShellSurfaceInterface *surface)
 {
     m_plasmaShellSurface = surface;
     auto updatePosition = [this, surface] {
         // That's a mis-use of doSetGeometry method. One should instead use move method.
         QRect rect = QRect(surface->position(), size());
         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::CriticalNotification:
             type = NET::CriticalNotification;
             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 || type == NET::CriticalNotification) {
                 setOnAllDesktops(true);
             }
             workspace()->updateClientArea();
         }
     };
     connect(surface, &PlasmaShellSurfaceInterface::panelTakesFocusChanged , this, [this, surface]() {
         if (surface->panelTakesFocus()) {
             workspace()->activateClient(this);
         }
     });
     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, &XdgShellClient::frameGeometryChanged, this, &XdgShellClient::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 XdgShellClient::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
         const QRect clientGeometry = frameGeometry();
         Qt::Edges edges;
         for (int i = 0; i < screens()->count(); i++) {
             const QRect screenGeometry = screens()->geometry(i);
             if (screenGeometry.left() == clientGeometry.left()) {
                 edges |= Qt::LeftEdge;
             }
             if (screenGeometry.right() == clientGeometry.right()) {
                 edges |= Qt::RightEdge;
             }
             if (screenGeometry.top() == clientGeometry.top()) {
                 edges |= Qt::TopEdge;
             }
             if (screenGeometry.bottom() == clientGeometry.bottom()) {
                 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 = [clientGeometry](Qt::Edges edges, Qt::Edge horiz, Qt::Edge vert) {
             if (edges.testFlag(horiz) && edges.testFlag(vert)) {
                 if (clientGeometry.width() >= clientGeometry.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 XdgShellClient::isInitialPositionSet() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->isPositionSet();
     }
     return false;
 }
 
 void XdgShellClient::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 XdgShellClient::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());
 }
 
 void XdgShellClient::updateColorScheme()
 {
     if (m_paletteInterface) {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(m_paletteInterface->palette()));
     } else {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(QString()));
     }
 }
 
 void XdgShellClient::updateMaximizeMode(MaximizeMode maximizeMode)
 {
     if (maximizeMode == m_maximizeMode) {
         return;
     }
 
     m_maximizeMode = maximizeMode;
     updateWindowRules(Rules::MaximizeHoriz | Rules::MaximizeVert | Rules::Position | Rules::Size);
 
     emit clientMaximizedStateChanged(this, m_maximizeMode);
     emit clientMaximizedStateChanged(this, m_maximizeMode & MaximizeHorizontal, m_maximizeMode & MaximizeVertical);
 }
 
 bool XdgShellClient::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;
 }
 
 quint32 XdgShellClient::windowId() const
 {
     return m_windowId;
 }
 
 void XdgShellClient::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 XdgShellClient::isTransient() const
 {
     return m_transient;
 }
 
 bool XdgShellClient::hasTransientPlacementHint() const
 {
     return isTransient() && transientFor() && m_xdgShellPopup;
 }
 
 QRect XdgShellClient::transientPlacement(const QRect &bounds) const
 {
     Q_ASSERT(m_xdgShellPopup);
 
     QRect anchorRect;
     Qt::Edges anchorEdge;
     Qt::Edges gravity;
     QPoint offset;
     PositionerConstraints constraintAdjustments;
     QSize size = frameGeometry().size();
 
     const QPoint parentClientPos = transientFor()->pos() + transientFor()->clientPos();
 
     // 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;
     };
 
     anchorRect = m_xdgShellPopup->anchorRect();
     anchorEdge = m_xdgShellPopup->anchorEdge();
     gravity = m_xdgShellPopup->gravity();
     offset = m_xdgShellPopup->anchorOffset();
     constraintAdjustments = m_xdgShellPopup->constraintAdjustments();
     if (!size.isValid()) {
         size = m_xdgShellPopup->initialSize();
     }
 
     QRect popupRect(popupOffset(anchorRect, anchorEdge, gravity, size) + offset + parentClientPos, size);
 
     //if that fits, we don't need to do anything
     if (inBounds(popupRect)) {
         return popupRect;
     }
     //otherwise apply constraint adjustment per axis in order XDG Shell Popup states
 
     if (constraintAdjustments & PositionerConstraint::FlipX) {
         if (!inBounds(popupRect, 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 flippedPopupRect = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity, size) + offset + parentClientPos, size);
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupRect, Qt::LeftEdge | Qt::RightEdge)) {
                 popupRect.moveLeft(flippedPopupRect.left());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideX) {
         if (!inBounds(popupRect, Qt::LeftEdge)) {
             popupRect.moveLeft(bounds.left());
         }
         if (!inBounds(popupRect, Qt::RightEdge)) {
             popupRect.moveRight(bounds.right());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeX) {
         QRect unconstrainedRect = popupRect;
 
         if (!inBounds(unconstrainedRect, Qt::LeftEdge)) {
             unconstrainedRect.setLeft(bounds.left());
         }
         if (!inBounds(unconstrainedRect, Qt::RightEdge)) {
             unconstrainedRect.setRight(bounds.right());
         }
 
         if (unconstrainedRect.isValid()) {
             popupRect = unconstrainedRect;
         }
     }
 
     if (constraintAdjustments & PositionerConstraint::FlipY) {
         if (!inBounds(popupRect, 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 flippedPopupRect = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity, size) + offset + parentClientPos, size);
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupRect, Qt::TopEdge | Qt::BottomEdge)) {
                 popupRect.moveTop(flippedPopupRect.top());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideY) {
         if (!inBounds(popupRect, Qt::TopEdge)) {
             popupRect.moveTop(bounds.top());
         }
         if (!inBounds(popupRect, Qt::BottomEdge)) {
             popupRect.moveBottom(bounds.bottom());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeY) {
         QRect unconstrainedRect = popupRect;
 
         if (!inBounds(unconstrainedRect, Qt::TopEdge)) {
             unconstrainedRect.setTop(bounds.top());
         }
         if (!inBounds(unconstrainedRect, Qt::BottomEdge)) {
             unconstrainedRect.setBottom(bounds.bottom());
         }
 
         if (unconstrainedRect.isValid()) {
             popupRect = unconstrainedRect;
         }
     }
 
     return popupRect;
 }
 
 QPoint XdgShellClient::popupOffset(const QRect &anchorRect, const Qt::Edges anchorEdge, const Qt::Edges gravity, const QSize popupSize) const
 {
     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;
 }
 
 void XdgShellClient::doResizeSync()
 {
     requestGeometry(moveResizeGeometry());
 }
 
 QMatrix4x4 XdgShellClient::inputTransformation() const
 {
     QMatrix4x4 matrix;
     matrix.translate(-m_bufferGeometry.x(), -m_bufferGeometry.y());
     return matrix;
 }
 
 void XdgShellClient::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 XdgShellClient 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 XdgShellClient::installXdgDecoration(XdgDecorationInterface *deco)
 {
     Q_ASSERT(m_xdgShellToplevel);
 
     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 XdgShellClient::shouldExposeToWindowManagement()
 {
     if (isLockScreen()) {
         return false;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 KWayland::Server::XdgShellSurfaceInterface::States XdgShellClient::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 XdgShellClient::doMinimize()
 {
     if (isMinimized()) {
         workspace()->clientHidden(this);
     } else {
         emit windowShown(this);
     }
     workspace()->updateMinimizedOfTransients(this);
 }
 
-void XdgShellClient::placeIn(const QRect &area)
-{
-    Placement::self()->place(this, area);
-    setGeometryRestore(frameGeometry());
-}
-
 void XdgShellClient::showOnScreenEdge()
 {
     if (!m_plasmaShellSurface || m_unmapped) {
         return;
     }
     hideClient(false);
     workspace()->raiseClient(this);
     if (m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AutoHide) {
         m_plasmaShellSurface->showAutoHidingPanel();
     }
 }
 
 bool XdgShellClient::dockWantsInput() const
 {
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Panel) {
             return m_plasmaShellSurface->panelTakesFocus();
         }
     }
     return false;
 }
 
 void XdgShellClient::killWindow()
 {
     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 XdgShellClient::isLocalhost() const
 {
     return true;
 }
 
 bool XdgShellClient::hasPopupGrab() const
 {
     return m_hasPopupGrab;
 }
 
 void XdgShellClient::popupDone()
 {
     if (m_xdgShellPopup) {
         m_xdgShellPopup->popupDone();
     }
 }
 
 void XdgShellClient::updateClientOutputs()
 {
     QVector<OutputInterface *> clientOutputs;
     const auto outputs = waylandServer()->display()->outputs();
     for (OutputInterface *output : outputs) {
         const QRect outputGeometry(output->globalPosition(), output->pixelSize() / output->scale());
         if (frameGeometry().intersects(outputGeometry)) {
             clientOutputs << output;
         }
     }
     surface()->setOutputs(clientOutputs);
 }
 
 bool XdgShellClient::isPopupWindow() const
 {
     if (Toplevel::isPopupWindow()) {
         return true;
     }
     if (m_xdgShellPopup != nullptr) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::supportsWindowRules() const
 {
     if (m_plasmaShellSurface) {
         return false;
     }
     return m_xdgShellToplevel;
 }
 
 QRect XdgShellClient::adjustMoveGeometry(const QRect &rect) const
 {
     QRect geometry = rect;
     geometry.moveTopLeft(moveResizeGeometry().topLeft());
     return geometry;
 }
 
 QRect XdgShellClient::adjustResizeGeometry(const QRect &rect) const
 {
     QRect geometry = rect;
 
     // We need to adjust frame geometry because configure events carry the maximum window geometry
     // size. A client that has aspect ratio can attach a buffer with smaller size than the one in
     // a configure event.
     switch (moveResizePointerMode()) {
     case PositionTopLeft:
         geometry.moveRight(moveResizeGeometry().right());
         geometry.moveBottom(moveResizeGeometry().bottom());
         break;
     case PositionTop:
     case PositionTopRight:
         geometry.moveLeft(moveResizeGeometry().left());
         geometry.moveBottom(moveResizeGeometry().bottom());
         break;
     case PositionRight:
     case PositionBottomRight:
     case PositionBottom:
         geometry.moveLeft(moveResizeGeometry().left());
         geometry.moveTop(moveResizeGeometry().top());
         break;
     case PositionBottomLeft:
     case PositionLeft:
         geometry.moveRight(moveResizeGeometry().right());
         geometry.moveTop(moveResizeGeometry().top());
         break;
     case PositionCenter:
         Q_UNREACHABLE();
     }
 
     return geometry;
 }
 
 void XdgShellClient::ping(PingReason reason)
 {
     Q_ASSERT(m_xdgShellToplevel);
 
     XdgShellInterface *shell = static_cast<XdgShellInterface *>(m_xdgShellToplevel->global());
     const quint32 serial = shell->ping(m_xdgShellToplevel);
     m_pingSerials.insert(serial, reason);
 }
 
 }
diff --git a/xdgshellclient.h b/xdgshellclient.h
index fd300c399..47fc363f6 100644
--- a/xdgshellclient.h
+++ b/xdgshellclient.h
@@ -1,272 +1,270 @@
 /********************************************************************
  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>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@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/>.
 *********************************************************************/
 
 #pragma once
 
 #include "abstract_client.h"
 
 #include <KWayland/Server/xdgshell_interface.h>
 
 namespace KWayland
 {
 namespace Server
 {
 class ServerSideDecorationInterface;
 class ServerSideDecorationPaletteInterface;
 class AppMenuInterface;
 class PlasmaShellSurfaceInterface;
 class XdgDecorationInterface;
 }
 }
 
 namespace KWin
 {
 
 /**
  * @brief The reason for which the server pinged a client surface
  */
 enum class PingReason {
     CloseWindow = 0,
     FocusWindow
 };
 
 class KWIN_EXPORT XdgShellClient : public AbstractClient
 {
     Q_OBJECT
 
 public:
     XdgShellClient(KWayland::Server::XdgShellSurfaceInterface *surface);
     XdgShellClient(KWayland::Server::XdgShellPopupInterface *surface);
     ~XdgShellClient() override;
 
     QRect inputGeometry() const override;
     QRect bufferGeometry() const override;
     QStringList activities() const override;
     QPoint clientContentPos() const override;
     QSize clientSize() const override;
     QSize minSize() const override;
     QSize maxSize() 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;
     void blockActivityUpdates(bool b = true) override;
     QString captionNormal() const override;
     QString captionSuffix() const override;
     void closeWindow() override;
     AbstractClient *findModal(bool allow_itself = false) override;
     bool isCloseable() const override;
     bool isFullScreenable() 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;
     void hideClient(bool hide) override;
     MaximizeMode maximizeMode() const override;
     MaximizeMode requestedMaximizeMode() const override;
     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::setFrameGeometry;
     void setFrameGeometry(int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet) override;
     bool hasStrut() const override;
     quint32 windowId() const override;
     pid_t pid() const override;
     bool isLockScreen() const override;
     bool isInputMethod() const override;
     bool isInitialPositionSet() const override;
     bool isTransient() const override;
     bool hasTransientPlacementHint() const override;
     QRect transientPlacement(const QRect &bounds) const override;
     QMatrix4x4 inputTransformation() const override;
     void showOnScreenEdge() override;
     bool hasPopupGrab() const override;
     void popupDone() override;
     void updateColorScheme() override;
     bool isPopupWindow() const override;
     void killWindow() override;
     bool isLocalhost() const override;
     bool supportsWindowRules() const override;
 
     void installPlasmaShellSurface(KWayland::Server::PlasmaShellSurfaceInterface *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);
 
-    void placeIn(const QRect &area);
-
 protected:
     void addDamage(const QRegion &damage) override;
     bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const override;
     void doSetActive() override;
     bool belongsToDesktop() const override;
     Layer layerForDock() const override;
     void changeMaximize(bool horizontal, bool vertical, bool adjust) override;
     void doResizeSync() override;
     bool acceptsFocus() const override;
     void doMinimize() override;
     void updateCaption() override;
     void doMove(int x, int y) override;
 
 private Q_SLOTS:
     void handleConfigureAcknowledged(quint32 serial);
     void handleTransientForChanged();
     void handleWindowClassChanged(const QByteArray &windowClass);
     void handleWindowGeometryChanged(const QRect &windowGeometry);
     void handleWindowTitleChanged(const QString &title);
     void handleMoveRequested(KWayland::Server::SeatInterface *seat, quint32 serial);
     void handleResizeRequested(KWayland::Server::SeatInterface *seat, quint32 serial, Qt::Edges edges);
     void handleMinimizeRequested();
     void handleMaximizeRequested(bool maximized);
     void handleFullScreenRequested(bool fullScreen, KWayland::Server::OutputInterface *output);
     void handleWindowMenuRequested(KWayland::Server::SeatInterface *seat, quint32 serial, const QPoint &surfacePos);
     void handleGrabRequested(KWayland::Server::SeatInterface *seat, quint32 serial);
     void handlePingDelayed(quint32 serial);
     void handlePingTimeout(quint32 serial);
     void handlePongReceived(quint32 serial);
     void handleCommitted();
 
 private:
     /**
      *  Called when the shell is created.
      */
     void init();
     /**
      * Called for the XDG case when the shell surface is committed to the surface.
      * At this point all initial properties should have been set by the client.
      */
     void finishInit();
     void createDecoration(const QRect &oldgeom);
     void destroyClient();
     void createWindowId();
     void updateIcon();
     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 QSize popupSize) const;
     void requestGeometry(const QRect &rect);
     void doSetGeometry(const QRect &rect);
     void unmap();
     void markAsMapped();
     QRect determineBufferGeometry() const;
     void ping(PingReason reason);
     static void deleteClient(XdgShellClient *c);
 
     QRect adjustMoveGeometry(const QRect &rect) const;
     QRect adjustResizeGeometry(const QRect &rect) const;
 
     KWayland::Server::XdgShellSurfaceInterface *m_xdgShellToplevel;
     KWayland::Server::XdgShellPopupInterface *m_xdgShellPopup;
 
     QRect m_bufferGeometry;
     QRect m_windowGeometry;
     bool m_hasWindowGeometry = false;
 
     // 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;
     bool m_unmapped = true;
     NET::WindowType m_windowType = NET::Normal;
     QPointer<KWayland::Server::PlasmaShellSurfaceInterface> m_plasmaShellSurface;
     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_hasPopupGrab = false;
     qreal m_opacity = 1.0;
 
     class RequestGeometryBlocker { //TODO rename ConfigureBlocker when this class is Xdg only
     public:
         RequestGeometryBlocker(XdgShellClient *client)
             : m_client(client)
         {
             m_client->m_requestGeometryBlockCounter++;
         }
         ~RequestGeometryBlocker()
         {
             m_client->m_requestGeometryBlockCounter--;
             if (m_client->m_requestGeometryBlockCounter == 0) {
                 m_client->requestGeometry(m_client->m_blockedRequestGeometry);
             }
         }
     private:
         XdgShellClient *m_client;
     };
     friend class RequestGeometryBlocker;
     int m_requestGeometryBlockCounter = 0;
     QRect m_blockedRequestGeometry;
     QString m_caption;
     QString m_captionSuffix;
     QHash<quint32, PingReason> m_pingSerials;
 
     bool m_isInitialized = false;
 
     friend class Workspace;
 };
 
 }
 
 Q_DECLARE_METATYPE(KWin::XdgShellClient *)