diff --git a/abstract_client.cpp b/abstract_client.cpp
index b01de8db6..2be743ec7 100644
--- a/abstract_client.cpp
+++ b/abstract_client.cpp
@@ -1,1988 +1,1987 @@
 /********************************************************************
  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 "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 "tabgroup.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
 {
 
 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::geometryShapeChanged, this, &AbstractClient::geometryChanged);
     auto signalMaximizeChanged = static_cast<void (AbstractClient::*)(KWin::AbstractClient*, MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged);
     connect(this, signalMaximizeChanged, this, &AbstractClient::geometryChanged);
     connect(this, &AbstractClient::clientStepUserMovedResized,   this, &AbstractClient::geometryChanged);
     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);
 
     // replace on-screen-display on size changes
     connect(this, &AbstractClient::geometryShapeChanged, this,
         [this] (Toplevel *c, const QRect &old) {
             Q_UNUSED(c)
             if (isOnScreenDisplay() && !geometry().isEmpty() && old.size() != geometry().size() && !isInitialPositionSet()) {
                 GeometryUpdatesBlocker blocker(this);
                 QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
                 Placement::self()->place(this, area);
                 setGeometryRestore(geometry());
             }
         }
     );
 
     connect(this, &AbstractClient::paddingChanged, this, [this]() {
         m_visibleRectBeforeGeometryUpdate = visibleRect();
     });
 
     connect(ApplicationMenu::self(), &ApplicationMenu::applicationMenuEnabledChanged, this, [this] {
         emit hasApplicationMenuChanged(hasApplicationMenu());
     });
 }
 
 AbstractClient::~AbstractClient()
 {
     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::setTabGroup(TabGroup* group)
 {
     tab_group = group;
     emit tabGroupChanged();
 }
 
 void AbstractClient::setClientShown(bool shown)
 {
     Q_UNUSED(shown)
 }
 
 bool AbstractClient::untab(const QRect &toGeometry, bool clientRemoved)
 {
     TabGroup *group = tab_group;
     if (group && group->remove(this)) { // remove sets the tabgroup to "0", therefore the pointer is cached
         if (group->isEmpty()) {
             delete group;
         }
         if (clientRemoved)
             return true; // there's been a broadcast signal that this client is now removed - don't touch it
         setClientShown(!(isMinimized() || isShade()));
         bool keepSize = toGeometry.size() == size();
         bool changedSize = false;
         if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
             changedSize = true;
             setQuickTileMode(QuickTileFlag::None); // if we leave a quicktiled group, assume that the user wants to untile
         }
         if (toGeometry.isValid()) {
             if (maximizeMode() != MaximizeRestore) {
                 changedSize = true;
                 maximize(MaximizeRestore); // explicitly calling for a geometry -> unmaximize
             }
             if (keepSize && changedSize) {
                 setGeometryRestore(geometry()); // checkWorkspacePosition() invokes it
                 QPoint cpoint = Cursor::pos();
                 QPoint point = cpoint;
                 point.setX((point.x() - toGeometry.x()) * geometryRestore().width() / toGeometry.width());
                 point.setY((point.y() - toGeometry.y()) * geometryRestore().height() / toGeometry.height());
                 auto geometry_restore = geometryRestore();
                 geometry_restore.moveTo(cpoint-point);
                 setGeometryRestore(geometry_restore);
             } else {
                 setGeometryRestore(toGeometry); // checkWorkspacePosition() invokes it
             }
             setGeometry(geometryRestore());
             checkWorkspacePosition();
         }
         return true;
     }
     return false;
 }
 
 bool AbstractClient::tabTo(AbstractClient *other, bool behind, bool activate)
 {
     Q_ASSERT(other && other != this);
 
     if (tab_group && tab_group == other->tabGroup()) { // special case: move inside group
         tab_group->move(this, other, behind);
         return true;
     }
 
     GeometryUpdatesBlocker blocker(this);
     const bool wasBlocking = signalsBlocked();
     blockSignals(true); // prevent client emitting "retabbed to nowhere" cause it's about to be entabbed the next moment
     untab();
     blockSignals(wasBlocking);
 
     TabGroup *newGroup = other->tabGroup() ? other->tabGroup() : new TabGroup(other);
 
     if (!newGroup->add(this, other, behind, activate)) {
         if (newGroup->count() < 2) { // adding "c" to "to" failed for whatever reason
             newGroup->remove(other);
             delete newGroup;
         }
         return false;
     }
     return true;
 }
 
 void AbstractClient::syncTabGroupFor(QString property, bool fromThisClient)
 {
     if (tab_group)
         tab_group->sync(property.toAscii().data(), fromThisClient ? this : tab_group->current());
 }
 
 bool AbstractClient::isCurrentTab() const
 {
     return !tab_group || tab_group->current() == this;
 }
 
 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 : NULL);
 
     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::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 (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 (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()) {
         // force hint change if different
         if (info && bool(info->state() & NET::KeepAbove) != keepAbove())
             info->setState(keepAbove() ? NET::KeepAbove : NET::States(0), NET::KeepAbove);
         return;
     }
     m_keepAbove = b;
     if (info) {
         info->setState(keepAbove() ? NET::KeepAbove : NET::States(0), NET::KeepAbove);
     }
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Above);
 
     doSetKeepAbove();
     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()) {
         // force hint change if different
         if (info && bool(info->state() & NET::KeepBelow) != keepBelow())
             info->setState(keepBelow() ? NET::KeepBelow : NET::States(0), NET::KeepBelow);
         return;
     }
     m_keepBelow = b;
     if (info) {
         info->setState(keepBelow() ? NET::KeepBelow : NET::States(0), NET::KeepBelow);
     }
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Below);
 
     doSetKeepBelow();
     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();
 }
 
 void AbstractClient::demandAttention(bool set)
 {
     if (isActive())
         set = false;
     if (m_demandsAttention == set)
         return;
     m_demandsAttention = set;
     if (info) {
         info->setState(set ? NET::DemandsAttention : NET::States(0), NET::DemandsAttention);
     }
     workspace()->clientAttentionChanged(this, set);
     emit demandsAttentionChanged();
 }
 
 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));
 
     VirtualDesktop *virtualDesktop = desktop == NET::OnAllDesktops ? nullptr : VirtualDesktopManager::self()->desktopForX11Id(desktop);
 
     if (m_desktops.contains(virtualDesktop)) {
         return;
     }
 
     int was_desk = AbstractClient::desktop();
     const bool wasOnCurrentDesktop = isOnCurrentDesktop() && was_desk >= 0;
 
-    //can't check windowManagementInterface yet as it gets created only on first show
-    //on x11 only one desktop at a time
+    //on x11 we can have only one desktop at a time
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         m_desktops.clear();
     }
     if (desktop == NET::OnAllDesktops) {
         m_desktops.clear();
     } else {
         //if would become on all desktops, clear the list, as empty == on all desktops
         if (m_desktops.count() > 1 && static_cast<uint>(m_desktops.count()) == VirtualDesktopManager::self()->count() - 1) {
             m_desktops.clear();
         } else {
             m_desktops << virtualDesktop;
         }
     }
     if (windowManagementInterface()) {
         if (m_desktops.isEmpty()) {
             windowManagementInterface()->setOnAllDesktops(true);
         } else {
             windowManagementInterface()->addPlasmaVirtualDesktop(virtualDesktop->id());
         }
     }
 
     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)->setDesktop(desktop);
 
     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->setDesktop(desktop);
     }
 
     doSetDesktop(desktop, was_desk);
 
     FocusChain::self()->update(this, FocusChain::MakeFirst);
     updateWindowRules(Rules::Desktop);
 
     emit desktopChanged();
     if (wasOnCurrentDesktop != isOnCurrentDesktop())
         emit desktopPresenceChanged(this, was_desk);
     emit x11DesktopIdsChanged();
 }
 
 void AbstractClient::doSetDesktop(int desktop, int was_desk)
 {
     Q_UNUSED(desktop)
     Q_UNUSED(was_desk)
 }
 
 void AbstractClient::unSetDesktop(int desktop)
 {
     VirtualDesktop *virtualDesktop = VirtualDesktopManager::self()->desktopForX11Id(desktop);
 
     m_desktops.removeAll(virtualDesktop);
 
     if (!windowManagementInterface()) {
         return;
     }
 
     windowManagementInterface()->removePlasmaVirtualDesktop(virtualDesktop->id());
     emit x11DesktopIdsChanged();
 }
 
 void AbstractClient::setOnAllDesktops(bool b)
 {
     if ((b && isOnAllDesktops()) ||
             (!b && !isOnAllDesktops()))
         return;
     if (b)
         setDesktop(NET::OnAllDesktops);
     else
         setDesktop(VirtualDesktopManager::self()->current());
 }
 
 QList<int> AbstractClient::x11DesktopIds() const
 {
     const auto desks = desktops();
     QList<int> 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;
 
     if (isShade() && info) // NETWM restriction - KWindowInfo::isMinimized() == Hidden && !Shaded
         info->setState(0, NET::Shaded);
 
     m_minimized = true;
 
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     FocusChain::self()->update(this, FocusChain::MakeFirstMinimized);
     // TODO: merge signal with s_minimized
     emit clientMinimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::unminimize(bool avoid_animation)
 {
     if (!isMinimized())
         return;
 
     if (rules()->checkMinimize(false)) {
         return;
     }
 
     if (isShade() && info) // NETWM restriction - KWindowInfo::isMinimized() == Hidden && !Shaded
         info->setState(NET::Shaded, NET::Shaded);
 
     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());
     }
 }
 
 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 (geometry().right() > area.right() && width() <= area.width())
         tx = area.right() - width() + 1;
     if (geometry().bottom() > area.bottom() && height() <= area.height())
         ty = area.bottom() - height() + 1;
     if (!area.contains(geometry().topLeft())) {
         if (tx < area.x())
             tx = area.x();
         if (ty < area.y())
             ty = area.y();
     }
     if (tx != x() || ty != y())
         move(tx, ty);
 }
 
 QSize AbstractClient::maxSize() const
 {
     return rules()->checkMaxSize(QSize(INT_MAX, INT_MAX));
 }
 
 QSize AbstractClient::minSize() const
 {
     return rules()->checkMinSize(QSize(0, 0));
 }
 
 void AbstractClient::updateMoveResize(const QPointF &currentGlobalCursor)
 {
     handleMoveResize(pos(), currentGlobalCursor.toPoint());
 }
 
 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 Client::actionSupported(), but both should be implemented.
     w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
     w->setGeometry(geom);
     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::geometryChanged, w,
         [w, this] {
             w->setGeometry(geom);
         }
     );
     connect(w, &PlasmaWindowInterface::closeRequested, this, [this] { closeWindow(); });
     connect(w, &PlasmaWindowInterface::moveRequested, this,
         [this] {
             Cursor::setPos(geometry().center());
             performMouseCommand(Options::MouseMove, Cursor::pos());
         }
     );
     connect(w, &PlasmaWindowInterface::resizeRequested, this,
         [this] {
             Cursor::setPos(geometry().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) {
                 workspace()->sendClientToDesktop(this, vd->x11DesktopNumber(), false);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::enterNewPlasmaVirtualDesktopRequested, this,
         [this] () {
             VirtualDesktopManager::self()->setCount(VirtualDesktopManager::self()->count() + 1);
             workspace()->sendClientToDesktop(this, VirtualDesktopManager::self()->count(), false);
         }
     );
     connect(w, &PlasmaWindowInterface::leavePlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 unSetDesktop(vd->x11DesktopNumber());
             }
         }
     );
 
     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) {
             ToplevelList::const_iterator  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->geometry().intersects(geometry()));
             }
         }
         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::MousePreviousTab:
         if (tabGroup())
             tabGroup()->activatePrev();
     break;
     case Options::MouseNextTab:
         if (tabGroup())
             tabGroup()->activateNext();
     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::MouseDragTab:
     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;
 }
 
 QPoint AbstractClient::transientPlacementHint() const
 {
     return QPoint();
 }
 
 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)
 {
     assert(!m_transients.contains(cl));
     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
 
 QSize AbstractClient::sizeForClientSize(const QSize &wsize, Sizemode mode, bool noframe) const
 {
     Q_UNUSED(mode)
     Q_UNUSED(noframe)
     return wsize + QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
 }
 
 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;
 }
 
 void AbstractClient::updateGeometryBeforeUpdateBlocking()
 {
     m_geometryBeforeUpdateBlocking = geom;
 }
 
 void AbstractClient::updateTabGroupStates(TabGroup::States)
 {
 }
 
 void AbstractClient::doMove(int, int)
 {
 }
 
 void AbstractClient::updateInitialMoveResizeGeometry()
 {
     m_moveResize.initialGeometry = geometry();
     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()->setClientIsMoving(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:
         finishMoveResize(false);
         setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     case Qt::Key_Escape:
         finishMoveResize(true);
         setMoveResizePointerButtonDown(false);
         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
             && com != Options::MouseDragTab) {
         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::MouseDragTab ||
                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());
         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();
 }
 
 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);
 }
 
 }
diff --git a/dbusinterface.cpp b/dbusinterface.cpp
index 48c41b141..89d3d1f5c 100644
--- a/dbusinterface.cpp
+++ b/dbusinterface.cpp
@@ -1,553 +1,544 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 // own
 #include "dbusinterface.h"
 #include "compositingadaptor.h"
 #include "virtualdesktopmanageradaptor.h"
 
 // kwin
 #include "abstract_client.h"
 #include "atoms.h"
 #include "composite.h"
 #include "debug_console.h"
 #include "main.h"
 #include "placement.h"
 #include "platform.h"
 #include "kwinadaptor.h"
 #include "scene.h"
 #include "workspace.h"
 #include "virtualdesktops.h"
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 
 // Qt
 #include <QOpenGLContext>
 #include <QDBusServiceWatcher>
 
 
 // Marshall the DBusDesktopDataStruct data into a D-BUS argument
 const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataStruct &desk)
 {
     argument.beginStructure();
     argument << desk.x11DesktopNumber;
     argument << desk.id;
     argument << desk.name;
     argument.endStructure();
     return argument;
 }
 // Retrieve
 const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataStruct &desk)
 {
     argument.beginStructure();
     argument >> desk.x11DesktopNumber;
     argument >> desk.id;
     argument >> desk.name;
     argument.endStructure();
     return argument;
 }
 
 const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataVector &deskVector)
 {
     argument.beginArray(qMetaTypeId<KWin::DBusDesktopDataStruct>());
     for (int i = 0; i < deskVector.size(); ++i) {
         argument << deskVector[i];
     }
     argument.endArray();
     return argument;
 }
 
 const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataVector &deskVector)
 {
     argument.beginArray();
     deskVector.clear();
 
     while (!argument.atEnd()) {
         KWin::DBusDesktopDataStruct element;
         argument >> element;
         deskVector.append(element);
     }
 
     argument.endArray();
 
     return argument;
 }
 
 
 namespace KWin
 {
 
 DBusInterface::DBusInterface(QObject *parent)
     : QObject(parent)
     , m_serviceName(QStringLiteral("org.kde.KWin"))
 {
     (void) new KWinAdaptor(this);
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/KWin"), this);
     const QByteArray dBusSuffix = qgetenv("KWIN_DBUS_SERVICE_SUFFIX");
     if (!dBusSuffix.isNull()) {
         m_serviceName = m_serviceName + QLatin1Char('.') + dBusSuffix;
     }
     if (!dbus.registerService(m_serviceName)) {
         QDBusServiceWatcher *dog = new QDBusServiceWatcher(m_serviceName, dbus, QDBusServiceWatcher::WatchForUnregistration, this);
         connect (dog, SIGNAL(serviceUnregistered(QString)), SLOT(becomeKWinService(QString)));
     } else {
         announceService();
     }
     dbus.connect(QString(), QStringLiteral("/KWin"), QStringLiteral("org.kde.KWin"), QStringLiteral("reloadConfig"),
                  Workspace::self(), SLOT(slotReloadConfig()));
     connect(kwinApp(), &Application::x11ConnectionChanged, this, &DBusInterface::announceService);
 }
 
 void DBusInterface::becomeKWinService(const QString &service)
 {
     // TODO: this watchdog exists to make really safe that we at some point get the service
     // but it's probably no longer needed since we explicitly unregister the service with the deconstructor
     if (service == m_serviceName && QDBusConnection::sessionBus().registerService(m_serviceName) && sender()) {
         sender()->deleteLater(); // bye doggy :'(
         announceService();
     }
 }
 
 DBusInterface::~DBusInterface()
 {
     QDBusConnection::sessionBus().unregisterService(m_serviceName);
     // KApplication automatically also grabs org.kde.kwin, so it's often been used externally - ensure to free it as well
     QDBusConnection::sessionBus().unregisterService(QStringLiteral("org.kde.kwin"));
     if (kwinApp()->x11Connection()) {
         xcb_delete_property(kwinApp()->x11Connection(), kwinApp()->x11RootWindow(), atoms->kwin_dbus_service);
     }
 }
 
 void DBusInterface::announceService()
 {
     if (!kwinApp()->x11Connection()) {
         return;
     }
     const QByteArray service = m_serviceName.toUtf8();
     xcb_change_property(kwinApp()->x11Connection(), XCB_PROP_MODE_REPLACE, kwinApp()->x11RootWindow(), atoms->kwin_dbus_service,
                         atoms->utf8_string, 8, service.size(), service.constData());
 }
 
 // wrap void methods with no arguments to Workspace
 #define WRAP(name) \
 void DBusInterface::name() \
 {\
     Workspace::self()->name();\
 }
 
 WRAP(reconfigure)
 
 #undef WRAP
 
 void DBusInterface::killWindow()
 {
     Workspace::self()->slotKillWindow();
 }
 
 #define WRAP(name) \
 void DBusInterface::name() \
 {\
     Placement::self()->name();\
 }
 
 WRAP(cascadeDesktop)
 WRAP(unclutterDesktop)
 
 #undef WRAP
 
 // wrap returning methods with no arguments to Workspace
 #define WRAP( rettype, name ) \
 rettype DBusInterface::name( ) \
 {\
     return Workspace::self()->name(); \
 }
 
 WRAP(QString, supportInformation)
 
 #undef WRAP
 
 bool DBusInterface::startActivity(const QString &in0)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return false;
     }
     return Activities::self()->start(in0);
 #else
     Q_UNUSED(in0)
     return false;
 #endif
 }
 
 bool DBusInterface::stopActivity(const QString &in0)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return false;
     }
     return Activities::self()->stop(in0);
 #else
     Q_UNUSED(in0)
     return false;
 #endif
 }
 
 int DBusInterface::currentDesktop()
 {
     return VirtualDesktopManager::self()->current();
 }
 
 bool DBusInterface::setCurrentDesktop(int desktop)
 {
     return VirtualDesktopManager::self()->setCurrent(desktop);
 }
 
 void DBusInterface::nextDesktop()
 {
     VirtualDesktopManager::self()->moveTo<DesktopNext>();
 }
 
 void DBusInterface::previousDesktop()
 {
     VirtualDesktopManager::self()->moveTo<DesktopPrevious>();
 }
 
 void DBusInterface::showDebugConsole()
 {
     DebugConsole *console = new DebugConsole;
     console->show();
 }
 
 QVariantMap DBusInterface::queryWindowInfo()
 {
     m_replyQueryWindowInfo = message();
     setDelayedReply(true);
     kwinApp()->platform()->startInteractiveWindowSelection(
         [this] (Toplevel *t) {
             if (auto c = qobject_cast<AbstractClient*>(t)) {
                 const QVariantMap ret{
                     {QStringLiteral("resourceClass"), c->resourceClass()},
                     {QStringLiteral("resourceName"), c->resourceName()},
                     {QStringLiteral("desktopFile"), c->desktopFileName()},
                     {QStringLiteral("role"), c->windowRole()},
                     {QStringLiteral("caption"), c->captionNormal()},
                     {QStringLiteral("clientMachine"), c->wmClientMachine(true)},
                     {QStringLiteral("type"), c->windowType()},
                     {QStringLiteral("x"), c->x()},
                     {QStringLiteral("y"), c->y()},
                     {QStringLiteral("width"), c->width()},
                     {QStringLiteral("height"), c->height()},
                     {QStringLiteral("x11DesktopNumber"), c->desktop()},
                     {QStringLiteral("minimized"), c->isMinimized()},
                     {QStringLiteral("shaded"), c->isShade()},
                     {QStringLiteral("fullscreen"), c->isFullScreen()},
                     {QStringLiteral("keepAbove"), c->keepAbove()},
                     {QStringLiteral("keepBelow"), c->keepBelow()},
                     {QStringLiteral("noBorder"), c->noBorder()},
                     {QStringLiteral("skipTaskbar"), c->skipTaskbar()},
                     {QStringLiteral("skipPager"), c->skipPager()},
                     {QStringLiteral("skipSwitcher"), c->skipSwitcher()},
                     {QStringLiteral("maximizeHorizontal"), c->maximizeMode() & MaximizeHorizontal},
                     {QStringLiteral("maximizeVertical"), c->maximizeMode() & MaximizeVertical}
                 };
                 QDBusConnection::sessionBus().send(m_replyQueryWindowInfo.createReply(ret));
             } else {
                 QDBusConnection::sessionBus().send(m_replyQueryWindowInfo.createErrorReply(QString(), QString()));
             }
         }
     );
     return QVariantMap{};
 }
 
 CompositorDBusInterface::CompositorDBusInterface(Compositor *parent)
     : QObject(parent)
     , m_compositor(parent)
 {
     connect(m_compositor, &Compositor::compositingToggled, this, &CompositorDBusInterface::compositingToggled);
     new CompositingAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Compositor"), this);
     dbus.connect(QString(), QStringLiteral("/Compositor"), QStringLiteral("org.kde.kwin.Compositing"),
                  QStringLiteral("reinit"), m_compositor, SLOT(slotReinitialize()));
 }
 
 QString CompositorDBusInterface::compositingNotPossibleReason() const
 {
     return kwinApp()->platform()->compositingNotPossibleReason();
 }
 
 QString CompositorDBusInterface::compositingType() const
 {
     if (!m_compositor->hasScene()) {
         return QStringLiteral("none");
     }
     switch (m_compositor->scene()->compositingType()) {
     case XRenderCompositing:
         return QStringLiteral("xrender");
     case OpenGL2Compositing:
         if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES) {
             return QStringLiteral("gles");
         } else {
             return QStringLiteral("gl2");
         }
     case QPainterCompositing:
         return QStringLiteral("qpainter");
     case NoCompositing:
     default:
         return QStringLiteral("none");
     }
 }
 
 bool CompositorDBusInterface::isActive() const
 {
     return m_compositor->isActive();
 }
 
 bool CompositorDBusInterface::isCompositingPossible() const
 {
     return kwinApp()->platform()->compositingPossible();
 }
 
 bool CompositorDBusInterface::isOpenGLBroken() const
 {
     return kwinApp()->platform()->openGLCompositingIsBroken();
 }
 
 bool CompositorDBusInterface::platformRequiresCompositing() const
 {
     return kwinApp()->platform()->requiresCompositing();
 }
 
 void CompositorDBusInterface::resume()
 {
     m_compositor->resume(Compositor::ScriptSuspend);
 }
 
 void CompositorDBusInterface::suspend()
 {
     m_compositor->suspend(Compositor::ScriptSuspend);
 }
 
 QStringList CompositorDBusInterface::supportedOpenGLPlatformInterfaces() const
 {
     QStringList interfaces;
     bool supportsGlx = false;
 #if HAVE_EPOXY_GLX
     supportsGlx = (kwinApp()->operationMode() == Application::OperationModeX11);
 #endif
     if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES) {
         supportsGlx = false;
     }
     if (supportsGlx) {
         interfaces << QStringLiteral("glx");
     }
     interfaces << QStringLiteral("egl");
     return interfaces;
 }
 
 
 
 
 VirtualDesktopManagerDBusInterface::VirtualDesktopManagerDBusInterface(VirtualDesktopManager *parent)
     : QObject(parent)
     , m_manager(parent)
 {
     qDBusRegisterMetaType<KWin::DBusDesktopDataStruct>();
     qDBusRegisterMetaType<KWin::DBusDesktopDataVector>();
 
     new VirtualDesktopManagerAdaptor(this);
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/VirtualDesktopManager"),
         QStringLiteral("org.kde.KWin.VirtualDesktopManager"),
         this
     );
 
     connect(m_manager, &VirtualDesktopManager::currentChanged, this,
         [this](uint previousDesktop, uint newDesktop) {
             Q_UNUSED(previousDesktop);
             Q_UNUSED(newDesktop);
             emit currentChanged(m_manager->currentDesktop()->id());
         }
     );
 
     connect(m_manager, &VirtualDesktopManager::countChanged, this,
         [this](uint previousCount, uint newCount) {
             Q_UNUSED(previousCount);
             emit countChanged(newCount);
             emit desktopsChanged(desktops());
         }
     );
 
     connect(m_manager, &VirtualDesktopManager::navigationWrappingAroundChanged, this,
         [this]() {
             emit navigationWrappingAroundChanged(isNavigationWrappingAround());
         }
     );
 
     connect(m_manager, &VirtualDesktopManager::rowsChanged, this, &VirtualDesktopManagerDBusInterface::rowsChanged);
 
     for (auto *vd : m_manager->desktops()) {
         connect(vd, &VirtualDesktop::x11DesktopNumberChanged, this,
             [this, vd]() {
                 DBusDesktopDataStruct data{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
                 emit desktopDataChanged(vd->id(), data);
                 emit desktopsChanged(desktops());
             }
         );
         connect(vd, &VirtualDesktop::nameChanged, this,
             [this, vd]() {
                 DBusDesktopDataStruct data{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
                 emit desktopDataChanged(vd->id(), data);
                 emit desktopsChanged(desktops());
             }
         );
     }
     connect(m_manager, &VirtualDesktopManager::desktopCreated, this,
         [this](VirtualDesktop *vd) {
             connect(vd, &VirtualDesktop::x11DesktopNumberChanged, this,
                 [this, vd]() {
                     DBusDesktopDataStruct data{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
                     emit desktopDataChanged(vd->id(), data);
                     emit desktopsChanged(desktops());
                 }
             );
             connect(vd, &VirtualDesktop::nameChanged, this,
                 [this, vd]() {
                     DBusDesktopDataStruct data{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
                     emit desktopDataChanged(vd->id(), data);
                     emit desktopsChanged(desktops());
                 }
             );
             DBusDesktopDataStruct data{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
             emit desktopCreated(vd->id(), data);
             emit desktopsChanged(desktops());
         }
     );
     connect(m_manager, &VirtualDesktopManager::desktopRemoved, this,
         [this](VirtualDesktop *vd) {
             emit desktopRemoved(vd->id());
             emit desktopsChanged(desktops());
         }
     );
 }
 
-void VirtualDesktopManagerDBusInterface::setCount(uint count)
-{
-    if (m_manager->count() == count) {
-        return;
-    }
-
-    m_manager->setCount(count);
-}
-
 uint VirtualDesktopManagerDBusInterface::count() const
 {
     return m_manager->count();
 }
 
 void VirtualDesktopManagerDBusInterface::setRows(uint rows)
 {
     if (static_cast<uint>(m_manager->grid().height()) == rows) {
         return;
     }
 
     m_manager->setRows(rows);
     m_manager->save();
 }
 
 uint VirtualDesktopManagerDBusInterface::rows() const
 {
     return m_manager->rows();
 }
 
 void VirtualDesktopManagerDBusInterface::setCurrent(const QString &id)
 {
     if (m_manager->currentDesktop()->id() == id) {
         return;
     }
 
     auto *vd = m_manager->desktopForId(id.toUtf8());
     if (vd) {
         m_manager->setCurrent(vd);
     }
 }
 
 QString VirtualDesktopManagerDBusInterface::current() const
 {
     return m_manager->currentDesktop()->id();
 }
 
 void VirtualDesktopManagerDBusInterface::setNavigationWrappingAround(bool wraps)
 {
     if (m_manager->isNavigationWrappingAround() == wraps) {
         return;
     }
 
     m_manager->setNavigationWrappingAround(wraps);
 }
 
 bool VirtualDesktopManagerDBusInterface::isNavigationWrappingAround() const
 {
     return m_manager->isNavigationWrappingAround();
 }
 
 DBusDesktopDataVector VirtualDesktopManagerDBusInterface::desktops() const
 {
     const auto desks = m_manager->desktops();
     DBusDesktopDataVector desktopVect;
     desktopVect.reserve(m_manager->count());
 
     std::transform(desks.constBegin(), desks.constEnd(),
         std::back_inserter(desktopVect),
         [] (const VirtualDesktop *vd) {
             return DBusDesktopDataStruct{.x11DesktopNumber = vd->x11DesktopNumber(), .id = vd->id(), .name = vd->name()};
         }
     );
 
     return desktopVect;
 }
 
 void VirtualDesktopManagerDBusInterface::createDesktop(uint position, const QString &name)
 {
     m_manager->createVirtualDesktop(position, name);
 }
 
 void VirtualDesktopManagerDBusInterface::setDesktopName(const QString &id, const QString &name)
 {
     VirtualDesktop *vd = m_manager->desktopForId(id.toUtf8());
     if (!vd) {
         return;
     }
     if (vd->name() == name) {
         return;
     }
 
     vd->setName(name);
     m_manager->save();
 }
 
 void VirtualDesktopManagerDBusInterface::removeDesktop(const QString &id)
 {
     m_manager->removeVirtualDesktop(id.toUtf8());
 }
 
 } // namespace
diff --git a/dbusinterface.h b/dbusinterface.h
index b944f0489..8d40df814 100644
--- a/dbusinterface.h
+++ b/dbusinterface.h
@@ -1,263 +1,262 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_DBUS_INTERFACE_H
 #define KWIN_DBUS_INTERFACE_H
 
 #include <QObject>
 #include <QtDBus>
 
 namespace KWin
 {
 
 class Compositor;
 class VirtualDesktopManager;
 
 /**
  * @brief This class is a wrapper for the org.kde.KWin D-Bus interface.
  *
  * The main purpose of this class is to be exported on the D-Bus as object /KWin.
  * It is a pure wrapper to provide the deprecated D-Bus methods which have been
  * removed from Workspace which used to implement the complete D-Bus interface.
  *
  * Nowadays the D-Bus interfaces are distributed, parts of it are exported on
  * /Compositor, parts on /Effects and parts on /KWin. The implementation in this
  * class just delegates the method calls to the actual implementation in one of the
  * three singletons.
  *
  * @author Martin Gräßlin <mgraesslin@kde.org>
  **/
 class DBusInterface: public QObject, protected QDBusContext
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KWin")
 public:
     explicit DBusInterface(QObject *parent);
     virtual ~DBusInterface();
 
 public: // PROPERTIES
 public Q_SLOTS: // METHODS
     Q_NOREPLY void cascadeDesktop();
     int currentDesktop();
     Q_NOREPLY void killWindow();
     void nextDesktop();
     void previousDesktop();
     Q_NOREPLY void reconfigure();
     bool setCurrentDesktop(int desktop);
     bool startActivity(const QString &in0);
     bool stopActivity(const QString &in0);
     QString supportInformation();
     Q_NOREPLY void unclutterDesktop();
     Q_NOREPLY void showDebugConsole();
 
     QVariantMap queryWindowInfo();
 
 private Q_SLOTS:
     void becomeKWinService(const QString &service);
 
 private:
     void announceService();
     QString m_serviceName;
     QDBusMessage m_replyQueryWindowInfo;
 };
 
 class CompositorDBusInterface : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Compositing")
     /**
      * @brief Whether the Compositor is active. That is a Scene is present and the Compositor is
      * not shutting down itself.
      **/
     Q_PROPERTY(bool active READ isActive)
     /**
      * @brief Whether compositing is possible. Mostly means whether the required X extensions
      * are available.
      **/
     Q_PROPERTY(bool compositingPossible READ isCompositingPossible)
     /**
      * @brief The reason why compositing is not possible. Empty String if compositing is possible.
      **/
     Q_PROPERTY(QString compositingNotPossibleReason READ compositingNotPossibleReason)
     /**
      * @brief Whether OpenGL has failed badly in the past (crash) and is considered as broken.
      **/
     Q_PROPERTY(bool openGLIsBroken READ isOpenGLBroken)
     /**
      * The type of the currently used Scene:
      * @li @c none No Compositing
      * @li @c xrender XRender
      * @li @c gl1 OpenGL 1
      * @li @c gl2 OpenGL 2
      * @li @c gles OpenGL ES 2
      **/
     Q_PROPERTY(QString compositingType READ compositingType)
     /**
      * @brief All currently supported OpenGLPlatformInterfaces.
      *
      * Possible values:
      * @li glx
      * @li egl
      *
      * Values depend on operation mode and compile time options.
      **/
     Q_PROPERTY(QStringList supportedOpenGLPlatformInterfaces READ supportedOpenGLPlatformInterfaces)
     Q_PROPERTY(bool platformRequiresCompositing READ platformRequiresCompositing)
 public:
     explicit CompositorDBusInterface(Compositor *parent);
     virtual ~CompositorDBusInterface() = default;
 
     bool isActive() const;
     bool isCompositingPossible() const;
     QString compositingNotPossibleReason() const;
     bool isOpenGLBroken() const;
     QString compositingType() const;
     QStringList supportedOpenGLPlatformInterfaces() const;
     bool platformRequiresCompositing() const;
 
 public Q_SLOTS:
     /**
      * @brief Suspends the Compositor if it is currently active.
      *
      * Note: it is possible that the Compositor is not able to suspend. Use @link isActive to check
      * whether the Compositor has been suspended.
      *
      * @return void
      * @see resume
      * @see isActive
      **/
     void suspend();
     /**
      * @brief Resumes the Compositor if it is currently suspended.
      *
      * Note: it is possible that the Compositor cannot be resumed, that is there might be Clients
      * blocking the usage of Compositing or the Scene might be broken. Use @link isActive to check
      * whether the Compositor has been resumed. Also check @link isCompositingPossible and
      * @link isOpenGLBroken.
      *
      * Note: The starting of the Compositor can require some time and is partially done threaded.
      * After this method returns the setup may not have been completed.
      *
      * @return void
      * @see suspend
      * @see isActive
      * @see isCompositingPossible
      * @see isOpenGLBroken
      **/
     void resume();
 
 Q_SIGNALS:
     void compositingToggled(bool active);
 
 private:
     Compositor *m_compositor;
 };
 
 //TODO: disable all of this in case of kiosk?
 
 struct DBusDesktopDataStruct {
     uint x11DesktopNumber;
     QString id;
     QString name;
 };
 typedef QVector<DBusDesktopDataStruct> DBusDesktopDataVector;
 
 class VirtualDesktopManagerDBusInterface : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KWin.VirtualDesktopManager")
 
     /**
      * The number of virtual desktops currently available.
      * The ids of the virtual desktops are in the range [1, VirtualDesktopManager::maximum()].
      **/
-    Q_PROPERTY(uint count READ count WRITE setCount NOTIFY countChanged)
+    Q_PROPERTY(uint count READ count NOTIFY countChanged)
     /**
      * The number of rows the virtual desktops will be laid out in
      **/
     Q_PROPERTY(uint rows READ rows WRITE setRows NOTIFY rowsChanged)
     /**
      * The id of the virtual desktop which is currently in use.
      **/
     Q_PROPERTY(QString current READ current WRITE setCurrent NOTIFY currentChanged)
     /**
      * Whether navigation in the desktop layout wraps around at the borders.
      **/
     Q_PROPERTY(bool navigationWrappingAround READ isNavigationWrappingAround WRITE setNavigationWrappingAround NOTIFY navigationWrappingAroundChanged)
 
     /**
      * list of key/value pairs which every one of them is representing a desktop
      */
     Q_PROPERTY(KWin::DBusDesktopDataVector desktops READ desktops NOTIFY desktopsChanged);
 
 public:
     VirtualDesktopManagerDBusInterface(VirtualDesktopManager *parent);
     ~VirtualDesktopManagerDBusInterface() = default;
 
-    void setCount(uint count);
     uint count() const;
 
     void setRows(uint rows);
     uint rows() const;
 
     void setCurrent(const QString &id);
     QString current() const;
 
     void setNavigationWrappingAround(bool wraps);
     bool isNavigationWrappingAround() const;
 
     KWin::DBusDesktopDataVector desktops() const;
 
 Q_SIGNALS:
     void countChanged(uint count);
     void rowsChanged(uint rows);
     void currentChanged(const QString &id);
     void navigationWrappingAroundChanged(bool wraps);
     void desktopsChanged(KWin::DBusDesktopDataVector);
     void desktopDataChanged(const QString &id, KWin::DBusDesktopDataStruct);
     void desktopCreated(const QString &id, KWin::DBusDesktopDataStruct);
     void desktopRemoved(const QString &id);
 
 public Q_SLOTS:
     /**
      * Create a desktop with a new name at a given position
      * note: the position starts from 1
      */
     void createDesktop(uint position, const QString &name);
     void setDesktopName(const QString &id, const QString &name);
     void removeDesktop(const QString &id);
 
 private:
     VirtualDesktopManager *m_manager;
 };
 
 } // namespace
 
 const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataStruct &desk);
 const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataStruct &desk);
 
 Q_DECLARE_METATYPE(KWin::DBusDesktopDataStruct)
 
 const QDBusArgument &operator<<(QDBusArgument &argument, const KWin::DBusDesktopDataVector &deskVector);
 const QDBusArgument &operator>>(const QDBusArgument &argument, KWin::DBusDesktopDataVector &deskVector);
 
 Q_DECLARE_METATYPE(KWin::DBusDesktopDataVector)
 
 #endif // KWIN_DBUS_INTERFACE_H
diff --git a/org.kde.KWin.VirtualDesktopManager.xml b/org.kde.KWin.VirtualDesktopManager.xml
index cf1fc2d80..3283764f0 100644
--- a/org.kde.KWin.VirtualDesktopManager.xml
+++ b/org.kde.KWin.VirtualDesktopManager.xml
@@ -1,50 +1,50 @@
 <!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 <node>
   <interface name="org.kde.KWin.VirtualDesktopManager">
-    <property name="count" type="u" access="readwrite"/>
+    <property name="count" type="u" access="read"/>
     <property name="current" type="s" access="readwrite"/>
     <property name="rows" type="u" access="readwrite"/>
     <property name="navigationWrappingAround" type="b" access="readwrite"/>
     <property name="desktops" type="a(iss)" access="read">
         <annotation name="org.qtproject.QtDBus.QtTypeName" value="KWin::DBusDesktopDataVector"/>
     </property>
 
     <signal name="countChanged">
       <arg name="count" type="u" direction="out"/>
     </signal>
     <signal name="rowsChanged">
       <arg name="rows" type="u" direction="out"/>
     </signal>
     <signal name="currentChanged">
       <arg name="id" type="s" direction="out"/>
     </signal>
     <signal name="navigationWrappingAroundChanged">
       <arg name="navigationWrappingAround" type="b" direction="out"/>
     </signal>
     <signal name="desktopDataChanged">
       <arg name="id" type="s" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="KWin::DBusDesktopDataStruct"/>
       <arg name="desktopData" type="(iss)" direction="out"/>
     </signal>
     <signal name="desktopCreated">
       <arg name="id" type="s" direction="out"/>
       <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="KWin::DBusDesktopDataStruct"/>
       <arg name="desktopData" type="(iss)" direction="out"/>
     </signal>
     <signal name="desktopRemoved">
       <arg name="id" type="s" direction="out"/>
     </signal>
 
     <method name="createDesktop">
       <arg name="position" type="u" direction="in"/>
       <arg name="name" type="s" direction="in"/>
     </method>
     <method name="setDesktopName">
       <arg name="id" type="s" direction="in"/>
       <arg name="name" type="s" direction="in"/>
     </method>
     <method name="removeDesktop">
       <arg name="id" type="s" direction="in"/>
     </method>
   </interface>
 </node>
diff --git a/virtualdesktops.cpp b/virtualdesktops.cpp
index 905e82efc..73e7fca14 100644
--- a/virtualdesktops.cpp
+++ b/virtualdesktops.cpp
@@ -1,897 +1,896 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtualdesktops.h"
 #include "input.h"
 // KDE
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <NETWM>
 
 #include <KWayland/Server/plasmavirtualdesktop_interface.h>
 // Qt
 #include <QAction>
 #include <QUuid>
 
 #include <algorithm>
 #include <QDebug>
 namespace KWin {
 
 extern int screen_number;
 
 VirtualDesktop::VirtualDesktop(QObject *parent)
     : QObject(parent)
 {
 }
 
 VirtualDesktop::~VirtualDesktop()
 {
     emit aboutToBeDestroyed();
 }
 
 void VirtualDesktopManager::setVirtualDesktopManagement(KWayland::Server::PlasmaVirtualDesktopManagementInterface *management)
 {
     using namespace KWayland::Server;
     Q_ASSERT(!m_virtualDesktopManagement);
     m_virtualDesktopManagement = management;
 
     connect(this, &VirtualDesktopManager::desktopCreated, this,
         [this](VirtualDesktop *desktop) {
             using namespace KWayland::Server;
             PlasmaVirtualDesktopInterface *pvd = m_virtualDesktopManagement->createDesktop(desktop->id(), desktop->x11DesktopNumber() - 1);
             pvd->setName(desktop->name());
             pvd->sendDone();
             connect(desktop, &VirtualDesktop::nameChanged, this,
                 [this, desktop, pvd]() {
                     pvd->setName(desktop->name());
                 }
             );
         }
     );
 
     //handle removed: from VirtualDesktopManager to the wayland interface
     connect(this, &VirtualDesktopManager::desktopRemoved, this,
         [this](VirtualDesktop *desktop) {
             m_virtualDesktopManagement->removeDesktop(desktop->id());
         }
     );
 
     //create a new desktop when the client asks to
     connect (m_virtualDesktopManagement, &PlasmaVirtualDesktopManagementInterface::desktopCreateRequested, this,
         [this](const QString &name, quint32 position) {
             VirtualDesktop *vd = createVirtualDesktop(position);
             if (vd) {
                 vd->setName(name);
             }
         }
     );
 
     //remove when the client asks to
     connect (m_virtualDesktopManagement, &PlasmaVirtualDesktopManagementInterface::desktopRemoveRequested, this,
         [this](const QString &id) {
             //here there can be some nice kauthorized check?
             //remove only from VirtualDesktopManager, the other connections will remove it from m_virtualDesktopManagement as well
             removeVirtualDesktop(id.toUtf8());
         }
     );
 
     for (quint32 i = 1; i <= count(); ++i) {
         VirtualDesktop *internalDesktop = desktopForX11Id(i);
         PlasmaVirtualDesktopInterface *desktop = m_virtualDesktopManagement->createDesktop(internalDesktop->id());
 
         desktop->setName(desktop->name());
         desktop->sendDone();
 
         connect(desktop, &PlasmaVirtualDesktopInterface::activateRequested, this,
             [this, desktop] () {
                 setCurrent(desktopForId(desktop->id().toUtf8()));
             }
         );
     }
     //Now we are sure all ids are there
     save();
 
     connect(this, &VirtualDesktopManager::currentChanged, this,
         [this]() {
             for (auto *deskInt : m_virtualDesktopManagement->desktops()) {
                 if (deskInt->id() == currentDesktop()->id()) {
                     deskInt->setActive(true);
                 } else {
                     deskInt->setActive(false);
                 }
             }
         }
     );
 }
 
 void VirtualDesktop::setId(const QByteArray &id)
 {
     Q_ASSERT(m_id.isEmpty());
     m_id = id;
 }
 
 void VirtualDesktop::setX11DesktopNumber(uint number)
 {
     //x11DesktopNumber can be changed now
     if (static_cast<uint>(m_x11DesktopNumber) == number) {
         return;
     }
 
     m_x11DesktopNumber = number;
 
     if (m_x11DesktopNumber != 0) {
         emit x11DesktopNumberChanged();
     }
 }
 
 void VirtualDesktop::setName(const QString &name)
 {
     if (m_name == name) {
         return;
     }
     m_name = name;
     emit nameChanged();
 }
 
 VirtualDesktopGrid::VirtualDesktopGrid()
     : m_size(1, 2) // Default to tow rows
     , m_grid(QVector<QVector<VirtualDesktop*>>{QVector<VirtualDesktop*>{}, QVector<VirtualDesktop*>{}})
 {    
 }
 
 VirtualDesktopGrid::~VirtualDesktopGrid() = default;
 
 void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops)
 {
     // Set private variables
     m_size = size;
     const uint width = size.width();
     const uint height = size.height();
 
     m_grid.clear();
     auto it = desktops.begin();
     auto end = desktops.end();
     if (orientation == Qt::Horizontal) {
         for (uint y = 0; y < height; ++y) {
             QVector<VirtualDesktop*> row;
             for (uint x = 0; x < width && it != end; ++x) {
                 row << *it;
                 it++;
             }
             m_grid << row;
         }
     } else {
         for (uint y = 0; y < height; ++y) {
             m_grid << QVector<VirtualDesktop*>();
         }
         for (uint x = 0; x < width; ++x) {
             for (uint y = 0; y < height && it != end; ++y) {
                 auto &row = m_grid[y];
                 row << *it;
                 it++;
             }
         }
     }
 }
 
 QPoint VirtualDesktopGrid::gridCoords(uint id) const
 {
     return gridCoords(VirtualDesktopManager::self()->desktopForX11Id(id));
 }
 
 QPoint VirtualDesktopGrid::gridCoords(VirtualDesktop *vd) const
 {
     for (int y = 0; y < m_grid.count(); ++y) {
         const auto &row = m_grid.at(y);
         for (int x = 0; x < row.count(); ++x) {
             if (row.at(x) == vd) {
                 return QPoint(x, y);
             }
         }
     }
     return QPoint(-1, -1);
 }
 
 VirtualDesktop *VirtualDesktopGrid::at(const QPoint &coords) const
 {
     if (coords.y() >= m_grid.count()) {
         return nullptr;
     }
     const auto &row = m_grid.at(coords.y());
     if (coords.x() >= row.count()) {
         return nullptr;
     }
     return row.at(coords.x());
 }
 
 KWIN_SINGLETON_FACTORY_VARIABLE(VirtualDesktopManager, s_manager)
 
 VirtualDesktopManager::VirtualDesktopManager(QObject *parent)
     : QObject(parent)
     , m_navigationWrapsAround(false)
     , m_rootInfo(NULL)
 {
 }
 
 VirtualDesktopManager::~VirtualDesktopManager()
 {
     s_manager = NULL;
 }
 
 QString VirtualDesktopManager::name(uint desktop) const
 {
     if (!m_rootInfo) {
         return defaultName(desktop);
     }
     return QString::fromUtf8(m_rootInfo->desktopName(desktop));
 }
 
 uint VirtualDesktopManager::above(uint id, bool wrap) const
 {
     auto vd = above(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::above(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()--;
         if (coords.y() < 0) {
             if (wrap) {
                 coords.setY(m_grid.height() - 1);
             } else {
                 return desktop; // Already at the top-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toRight(uint id, bool wrap) const
 {
     auto vd = toRight(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toRight(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()++;
         if (coords.x() >= m_grid.width()) {
             if (wrap) {
                 coords.setX(0);
             } else {
                 return desktop; // Already at the right-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::below(uint id, bool wrap) const
 {
     auto vd = below(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::below(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()++;
         if (coords.y() >= m_grid.height()) {
             if (wrap) {
                 coords.setY(0);
             } else {
                 // Already at the bottom-most desktop
                 return desktop;
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toLeft(uint id, bool wrap) const
 {
     auto vd = toLeft(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toLeft(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()--;
         if (coords.x() < 0) {
             if (wrap) {
                 coords.setX(m_grid.width() - 1);
             } else {
                 return desktop; // Already at the left-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 VirtualDesktop *VirtualDesktopManager::next(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     it++;
     if (it == m_desktops.end()) {
         if (wrap) {
             return m_desktops.first();
         } else {
             return desktop;
         }
     }
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::previous(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     if (it == m_desktops.begin()) {
         if (wrap) {
             return m_desktops.last();
         } else {
             return desktop;
         }
     }
     it--;
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::desktopForX11Id(uint id) const
 {
     if (id == 0 || id > count()) {
         return nullptr;
     }
     return m_desktops.at(id - 1);
 }
 
 VirtualDesktop *VirtualDesktopManager::desktopForId(const QByteArray &id) const
 {
     auto desk = std::find_if(
         m_desktops.constBegin(),
         m_desktops.constEnd(),
         [id] (const VirtualDesktop *desk ) {
             return desk->id() == id;
         }
     );
 
     if (desk != m_desktops.constEnd()) {
         return *desk;
     }
 
     return nullptr;
 }
 
 VirtualDesktop *VirtualDesktopManager::createVirtualDesktop(uint number, const QString &name)
 {
     //too many, can't insert new ones
     if ((uint)m_desktops.count() == VirtualDesktopManager::maximum()) {
         return nullptr;
     }
 
     const uint actualNumber = qBound<uint>(0, number, VirtualDesktopManager::maximum());
     auto *vd = new VirtualDesktop(this);
     vd->setX11DesktopNumber(actualNumber);
     //TODO: depend on Qt 5.11, use toString(QUuid::WithoutBraces)
     vd->setId(QUuid::createUuid().toString().toUtf8());
     vd->setName(name);
     if (m_rootInfo) {
         connect(vd, &VirtualDesktop::nameChanged, this,
             [this, vd]() {
                 if (m_rootInfo) {
                     m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
                 }
             }
         );
         m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
     }
 
     //update the id of displaced desktops
     for (uint i = actualNumber; i < (uint)m_desktops.count(); ++i) {
         m_desktops[i]->setX11DesktopNumber(i + 1);
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(i + 1, m_desktops[i]->name().toUtf8().data());
         }
     }
 
     m_desktops.insert(actualNumber - 1, vd);
     save();
 
     updateRootInfo();
     emit desktopCreated(vd);
     emit countChanged(m_desktops.count()-1, m_desktops.count());
     return vd;
 }
 
 void VirtualDesktopManager::removeVirtualDesktop(const QByteArray &id)
 {
     //don't end up without any desktop
     if (m_desktops.count() == 1) {
         return;
     }
     auto desktop = desktopForId(id);
     if (!desktop) {
         return;
     }
 
     const uint oldCurrent = m_current->x11DesktopNumber();
     const uint i = desktop->x11DesktopNumber() - 1;
     m_desktops.remove(i);
 
     for (uint j = i; j < (uint)m_desktops.count(); ++j) {
         m_desktops[j]->setX11DesktopNumber(j + 1);
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(j + 1, m_desktops[j]->name().toUtf8().data());
         }
     }
 
     const uint newCurrent = qMin(oldCurrent, (uint)m_desktops.count());
     m_current = m_desktops.at(newCurrent - 1);
     if (oldCurrent != newCurrent) {
         emit currentChanged(oldCurrent, newCurrent);
     }
 
     updateRootInfo();
     emit desktopRemoved(desktop);
     emit countChanged(m_desktops.count()+1, m_desktops.count());
 
     desktop->deleteLater();
 }
 
 uint VirtualDesktopManager::current() const
 {
     return m_current ? m_current->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::currentDesktop() const
 {
     return m_current;
 }
 
 bool VirtualDesktopManager::setCurrent(uint newDesktop)
 {
     if (newDesktop < 1 || newDesktop > count() || newDesktop == current()) {
         return false;
     }
     auto d = desktopForX11Id(newDesktop);
     Q_ASSERT(d);
     return setCurrent(d);
 }
 
 bool VirtualDesktopManager::setCurrent(VirtualDesktop *newDesktop)
 {
     Q_ASSERT(newDesktop);
     if (m_current == newDesktop) {
         return false;
     }
     const uint oldDesktop = current();
     m_current = newDesktop;
     emit currentChanged(oldDesktop, newDesktop->x11DesktopNumber());
     return true;
 }
 
 void VirtualDesktopManager::setCount(uint count)
 {
     count = qBound<uint>(1, count, VirtualDesktopManager::maximum());
     if (count == uint(m_desktops.count())) {
         // nothing to change
         return;
     }
     QList<VirtualDesktop *> newDesktops;
     const uint oldCount = m_desktops.count();
     //this explicit check makes it more readable
     if ((uint)m_desktops.count() > count) {
         const auto desktopsToRemove = m_desktops.mid(count);
         m_desktops.resize(count);
         uint oldCurrent = current();
         uint newCurrent = qMin(oldCurrent, count);
         m_current = m_desktops.at(newCurrent - 1);
         if (oldCurrent != newCurrent) {
             emit currentChanged(oldCurrent, newCurrent);
         }
         for (auto desktop : desktopsToRemove) {
             emit desktopRemoved(desktop);
             desktop->deleteLater();
         }
     } else {
         while (uint(m_desktops.count()) < count) {
             auto vd = new VirtualDesktop(this);
             vd->setX11DesktopNumber(m_desktops.count() + 1);
             if (!m_isLoading) {
                 vd->setId(QUuid::createUuid().toString().toUtf8());
             }
             m_desktops << vd;
             newDesktops << vd;
             if (m_rootInfo) {
                 connect(vd, &VirtualDesktop::nameChanged, this,
                     [this, vd]() {
                         if (m_rootInfo) {
                             m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
                         }
                     }
                 );
                 m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
             }
         }
     }
 
     updateRootInfo();
 
     save();
     for (auto vd : newDesktops) {
         emit desktopCreated(vd);
     }
     emit countChanged(oldCount, m_desktops.count());
 }
 
 
 uint VirtualDesktopManager::rows() const
 {
     return grid().height();
 }
 
 void VirtualDesktopManager::setRows(uint rows)
 {
     if (static_cast<uint>(grid().height()) == rows || rows == 0 || rows > count()) {
         return;
     }
 
     int columns = count() / rows;
     if (count() % rows > 0) {
         columns++;
     }
     if (m_rootInfo) {
         m_rootInfo->setDesktopLayout(NET::OrientationHorizontal, columns, rows, NET::DesktopLayoutCornerTopLeft);
         m_rootInfo->activate();
     }
 
     updateLayout();
 
     //rowsChanged will be emitted by setNETDesktopLayout called by updateLayout
 }
 
 void VirtualDesktopManager::updateRootInfo()
 {
     if (!m_rootInfo) {
         // Make sure the layout is still valid
         updateLayout();
         return;
     }
     const int n = count();
     m_rootInfo->setNumberOfDesktops(n);
     NETPoint *viewports = new NETPoint[n];
     m_rootInfo->setDesktopViewport(n, *viewports);
     delete[] viewports;
     // Make sure the layout is still valid
     updateLayout();
 }
 
 void VirtualDesktopManager::updateLayout()
 {
     int width = 0;
     int height = 0;
     Qt::Orientation orientation = Qt::Horizontal;
     if (m_rootInfo) {
         // TODO: Is there a sane way to avoid overriding the existing grid?
         width = m_rootInfo->desktopLayoutColumnsRows().width();
         height = m_rootInfo->desktopLayoutColumnsRows().height();
         orientation = m_rootInfo->desktopLayoutOrientation() == NET::OrientationHorizontal ? Qt::Horizontal : Qt::Vertical;
     }
     if (width == 0 && height == 0) {
         // Not given, set default layout
         height = count() == 1u ? 1 : 2;
     }
     setNETDesktopLayout(orientation,
         width, height, 0 //rootInfo->desktopLayoutCorner() // Not really worth implementing right now.
     );
 }
 
 static bool s_loadingDesktopSettings = false;
 
 void VirtualDesktopManager::load()
 {
     s_loadingDesktopSettings = true;
     if (!m_config) {
         return;
     }
     //FIXME: how to avoid this?
     m_isLoading = true;
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname.sprintf("Desktops-screen-%d", screen_number);
     }
     KConfigGroup group(m_config, groupname);
     const int n = group.readEntry("Number", 1);
     setCount(n);
-    //Use kactivitymanagerdrc directly?
 
     for (int i = 1; i <= n; i++) {
         QString s = group.readEntry(QStringLiteral("Name_%1").arg(i), i18n("Desktop %1", i));
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(i, s.toUtf8().data());
         }
         m_desktops[i-1]->setName(s.toUtf8().data());
 
         s = group.readEntry(QStringLiteral("Id_%1").arg(i), QString());
         if (s.isEmpty()) {
             s = QUuid::createUuid().toString();
         }
         //load gets called 2 times, see workspace.cpp line 416 and BUG 385260
         if (m_desktops[i-1]->id().isEmpty()) {
             m_desktops[i-1]->setId(s.toUtf8().data());
         } else {
             Q_ASSERT(m_desktops[i-1]->id() == s.toUtf8().data());
         }
 
         // TODO: update desktop focus chain, why?
 //         m_desktopFocusChain.value()[i-1] = i;
     }
 
     if (m_rootInfo) {
         int rows = group.readEntry<int>("Rows", 2);
         rows = qBound(1, rows, n);
         // avoid weird cases like having 3 rows for 4 desktops, where the last row is unused
         int columns = n / rows;
         if (n % rows > 0) {
             columns++;
         }
         m_rootInfo->setDesktopLayout(NET::OrientationHorizontal, columns, rows, NET::DesktopLayoutCornerTopLeft);
         m_rootInfo->activate();
     }
 
     s_loadingDesktopSettings = false;
     m_isLoading = false;
 }
 
 void VirtualDesktopManager::save()
 {
     if (s_loadingDesktopSettings) {
         return;
     }
     if (!m_config) {
         return;
     }
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname.sprintf("Desktops-screen-%d", screen_number);
     }
     KConfigGroup group(m_config, groupname);
 
     group.writeEntry("Number", count());
     for (uint i = 1; i <= count(); ++i) {
         QString s = name(i);
         const QString defaultvalue = defaultName(i);
         if (s.isEmpty()) {
             s = defaultvalue;
             if (m_rootInfo) {
                 m_rootInfo->setDesktopName(i, s.toUtf8().data());
             }
         }
 
         if (s != defaultvalue) {
             group.writeEntry(QStringLiteral("Name_%1").arg(i), s);
         } else {
             QString currentvalue = group.readEntry(QStringLiteral("Name_%1").arg(i), QString());
             if (currentvalue != defaultvalue) {
                 group.deleteEntry(QStringLiteral("Name_%1").arg(i));
             }
         }
         group.writeEntry(QStringLiteral("Id_%1").arg(i), m_desktops[i-1]->id());
     }
 
     // Save to disk
     group.sync();
 }
 
 QString VirtualDesktopManager::defaultName(int desktop) const
 {
     return i18n("Desktop %1", desktop);
 }
 
 void VirtualDesktopManager::setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner)
 {
     Q_UNUSED(startingCorner);   // Not really worth implementing right now.
     const uint count = m_desktops.count();
 
     // Calculate valid grid size
     Q_ASSERT(width > 0 || height > 0);
     if ((width <= 0) && (height > 0)) {
         width = (count + height - 1) / height;
     } else if ((height <= 0) && (width > 0)) {
         height = (count + width - 1) / width;
     }
     while (width * height < count) {
         if (orientation == Qt::Horizontal) {
             ++width;
         } else {
             ++height;
         }
     }
 
     m_grid.update(QSize(width, height), orientation, m_desktops);
     // TODO: why is there no call to m_rootInfo->setDesktopLayout?
     emit layoutChanged(width, height);
     emit rowsChanged(height);
 }
 
 void VirtualDesktopManager::initShortcuts()
 {
     initSwitchToShortcuts();
 
     QAction *nextAction = addAction(QStringLiteral("Switch to Next Desktop"), i18n("Switch to Next Desktop"), &VirtualDesktopManager::slotNext);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Right, nextAction);
     QAction *previousAction = addAction(QStringLiteral("Switch to Previous Desktop"), i18n("Switch to Previous Desktop"), &VirtualDesktopManager::slotPrevious);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Left, previousAction);
     addAction(QStringLiteral("Switch One Desktop to the Right"), i18n("Switch One Desktop to the Right"), &VirtualDesktopManager::slotRight);
     addAction(QStringLiteral("Switch One Desktop to the Left"), i18n("Switch One Desktop to the Left"), &VirtualDesktopManager::slotLeft);
     addAction(QStringLiteral("Switch One Desktop Up"), i18n("Switch One Desktop Up"), &VirtualDesktopManager::slotUp);
     addAction(QStringLiteral("Switch One Desktop Down"), i18n("Switch One Desktop Down"), &VirtualDesktopManager::slotDown);
 
     // axis events
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisDown,
                                   findChild<QAction*>(QStringLiteral("Switch to Next Desktop")));
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisUp,
                                   findChild<QAction*>(QStringLiteral("Switch to Previous Desktop")));
 }
 
 void VirtualDesktopManager::initSwitchToShortcuts()
 {
     const QString toDesktop = QStringLiteral("Switch to Desktop %1");
     const KLocalizedString toDesktopLabel = ki18n("Switch to Desktop %1");
     addAction(toDesktop, toDesktopLabel, 1, QKeySequence(Qt::CTRL + Qt::Key_F1), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 2, QKeySequence(Qt::CTRL + Qt::Key_F2), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 3, QKeySequence(Qt::CTRL + Qt::Key_F3), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 4, QKeySequence(Qt::CTRL + Qt::Key_F4), &VirtualDesktopManager::slotSwitchTo);
 
     for (uint i = 5; i <= maximum(); ++i) {
         addAction(toDesktop, toDesktopLabel, i, QKeySequence(), &VirtualDesktopManager::slotSwitchTo);
     }
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name.arg(value));
     a->setText(label.subs(value).toString());
     a->setData(value);
     KGlobalAccel::setGlobalShortcut(a, key);
     input()->registerShortcut(key, a, this, slot);
     return a;
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name);
     a->setText(label);
     KGlobalAccel::setGlobalShortcut(a, QKeySequence());
     input()->registerShortcut(QKeySequence(), a, this, slot);
     return a;
 }
 
 void VirtualDesktopManager::slotSwitchTo()
 {
     QAction *act = qobject_cast<QAction*>(sender());
     if (!act) {
         return;
     }
     bool ok = false;
     const uint i = act->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     setCurrent(i);
 }
 
 void VirtualDesktopManager::setNavigationWrappingAround(bool enabled)
 {
     if (enabled == m_navigationWrapsAround) {
         return;
     }
     m_navigationWrapsAround = enabled;
     emit navigationWrappingAroundChanged();
 }
 
 void VirtualDesktopManager::slotDown()
 {
     moveTo<DesktopBelow>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotLeft()
 {
     moveTo<DesktopLeft>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotPrevious()
 {
     moveTo<DesktopPrevious>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotNext()
 {
     moveTo<DesktopNext>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotRight()
 {
     moveTo<DesktopRight>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotUp()
 {
     moveTo<DesktopAbove>(isNavigationWrappingAround());
 }
 
 } // KWin
diff --git a/virtualdesktops.h b/virtualdesktops.h
index 42755669a..713cd50bc 100644
--- a/virtualdesktops.h
+++ b/virtualdesktops.h
@@ -1,736 +1,737 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_VIRTUAL_DESKTOPS_H
 #define KWIN_VIRTUAL_DESKTOPS_H
 // KWin
 #include <kwinglobals.h>
 #include <kwin_export.h>
 // Qt includes
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <QSize>
 
 // KDE includes
 #include <KConfig>
 #include <KSharedConfig>
 
 class KLocalizedString;
 class NETRootInfo;
 class QAction;
 
 namespace KWayland
 {
 namespace Server
 {
 class PlasmaVirtualDesktopManagementInterface;
 }
 }
 
 namespace KWin {
 
 class KWIN_EXPORT VirtualDesktop : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QByteArray id READ id CONSTANT)
     Q_PROPERTY(uint x11DesktopNumber READ x11DesktopNumber NOTIFY x11DesktopNumberChanged)
     Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
 public:
     explicit VirtualDesktop(QObject *parent = nullptr);
     virtual ~VirtualDesktop();
 
     void setId(const QByteArray &id);
     QByteArray id() const {
         return m_id;
     }
 
     void setName(const QString &name);
     QString name() const {
         return m_name;
     }
 
     void setX11DesktopNumber(uint number);
     uint x11DesktopNumber() const {
         return m_x11DesktopNumber;
     }
 
 Q_SIGNALS:
     void nameChanged();
     void x11DesktopNumberChanged();
     /**
      * Emitted just before the desktop gets destroyed.
      **/
     void aboutToBeDestroyed();
 
 private:
     QByteArray m_id;
     QString m_name;
     int m_x11DesktopNumber = 0;
 
 };
 
 /**
  * @brief Two dimensional grid containing the ID of the virtual desktop at a specific position
  * in the grid.
  *
  * The VirtualDesktopGrid represents a visual layout of the Virtual Desktops as they are in e.g.
  * a Pager. This grid is used for getting a desktop next to a given desktop in any direction by
  * making use of the layout information. This allows navigation like move to desktop on left.
  **/
 class VirtualDesktopGrid
 {
 public:
     VirtualDesktopGrid();
     ~VirtualDesktopGrid();
     void update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops);
     /**
      * @returns The coords of desktop @a id in grid units.
      */
     QPoint gridCoords(uint id) const;
     /**
      * @returns The coords of desktop @a vd in grid units.
      */
     QPoint gridCoords(VirtualDesktop *vd) const;
     /**
      * @returns The desktop at the point @a coords or 0 if no desktop exists at that
      * point. @a coords is to be in grid units.
      */
     VirtualDesktop *at(const QPoint &coords) const;
     int width() const;
     int height() const;
     const QSize &size() const;
 private:
     QSize m_size;
     QVector<QVector<VirtualDesktop*>> m_grid;
 };
 
 /**
  * @brief Manages the number of available virtual desktops, the layout of those and which virtual
  * desktop is the current one.
  *
  * This manager is responsible for Virtual Desktop handling inside KWin. It has a property for the
  * count of available virtual desktops and a property for the currently active virtual desktop. All
  * changes to the number of virtual desktops and the current virtual desktop need to go through this
  * manager.
  *
  * On all changes a signal is emitted and interested parties should connect to the signal. The manager
  * itself does not interact with other parts of the system. E.g. it does not hide/show windows of
  * desktop changes. This is outside the scope of this manager.
  *
  * Internally the manager organizes the virtual desktops in a grid allowing to navigate over the
  * virtual desktops. For this a set of convenient methods are available which allow to get the id
  * of an adjacent desktop or to switch to an adjacent desktop. Interested parties should make use of
  * these methods and not replicate the logic to switch to the next desktop.
  **/
 class KWIN_EXPORT VirtualDesktopManager : public QObject
 {
     Q_OBJECT
     /**
      * The number of virtual desktops currently available.
      * The ids of the virtual desktops are in the range [1, VirtualDesktopManager::maximum()].
      **/
     Q_PROPERTY(uint count READ count WRITE setCount NOTIFY countChanged)
     /**
      * The id of the virtual desktop which is currently in use.
      **/
     Q_PROPERTY(uint current READ current WRITE setCurrent NOTIFY currentChanged)
     /**
      * Whether navigation in the desktop layout wraps around at the borders.
      **/
     Q_PROPERTY(bool navigationWrappingAround READ isNavigationWrappingAround WRITE setNavigationWrappingAround NOTIFY navigationWrappingAroundChanged)
 public:
     virtual ~VirtualDesktopManager();
     /**
      * @internal, for X11 case
      **/
     void setRootInfo(NETRootInfo *info);
     /**
      * @internal, for Wayland case
      **/
     void setVirtualDesktopManagement(KWayland::Server::PlasmaVirtualDesktopManagementInterface *management);
     /**
      * @internal
      **/
     void setConfig(KSharedConfig::Ptr config);
     /**
      * @returns Total number of desktops currently in existence.
      * @see setCount
      * @see countChanged
      */
     uint count() const;
     /**
      * @returns the number of rows the layout has.
      * @see setRows
      * @see rowsChanged
      */
     uint rows() const;
     /**
      * @returns The ID of the current desktop.
      * @see setCurrent
      * @see currentChanged
      */
     uint current() const;
     /**
      * @returns The current desktop
      * @see setCurrent
      * @see currentChanged
      **/
     VirtualDesktop *currentDesktop() const;
     /**
      * Moves to the desktop through the algorithm described by Direction.
      * @param wrap If @c true wraps around to the other side of the layout
      * @see setCurrent
      **/
     template <typename Direction>
     void moveTo(bool wrap = false);
 
     /**
      * @returns The name of the @p desktop
      **/
     QString name(uint desktop) const;
 
     /**
      * @returns @c true if navigation at borders of layout wraps around, @c false otherwise
      * @see setNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      **/
     bool isNavigationWrappingAround() const;
 
     /**
      * @returns The layout aware virtual desktop grid used by this manager.
      **/
     const VirtualDesktopGrid &grid() const;
 
     /**
      * @returns The ID of the desktop above desktop @a id. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint above(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop above desktop @a desktop. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *above(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the right of desktop @a id. Wraps around to the
      * left of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toRight(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the right of desktop @a desktop. Wraps around to the
      * left of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toRight(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop below desktop @a id. Wraps around to the top of the
      * layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint below(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop below desktop @a desktop. Wraps around to the top of the
      * layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *below(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the left of desktop @a id. Wraps around to the
      * right of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toLeft(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the left of desktop @a desktop. Wraps around to the
      * right of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toLeft(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The desktop after the desktop @a desktop. Wraps around to the first
      * desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      **/
     VirtualDesktop *next(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
     /**
      * @returns The desktop in front of the desktop @a desktop. Wraps around to the
      * last desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      **/
     VirtualDesktop *previous(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
 
     void initShortcuts();
 
     /**
      * @returns all currently managed VirtualDesktops
      **/
     QVector<VirtualDesktop*> desktops() const {
         return m_desktops;
     }
 
     /**
      * @returns The VirtualDesktop for the x11 @p id, if no such VirtualDesktop @c null is returned
      **/
     VirtualDesktop *desktopForX11Id(uint id) const;
 
     /**
      * @returns The VirtualDesktop for the internal desktop string @p id, if no such VirtualDesktop @c null is returned
      **/
     VirtualDesktop *desktopForId(const QByteArray &id) const;
 
     /**
      * Create a new virtual desktop at the requested position.
      * The difference with setCount is that setCount always adds new desktops at the end of the chain. The Id is automatically generated.
      * @param x11DesktopNumber number for the desktop. The desktop created will have an
      *           x11DesktopNumber guaranteed to be between 1 and numberOfDesktops().
+     * Existing desktops will eventually have their x11DesktopNumber increased.
      * @param name The name for the new desktop, if empty the default name will be used.
      * @returns the new VirtualDesktop, nullptr if we reached the maximum number of desktops
      */
      VirtualDesktop *createVirtualDesktop(uint x11DesktopNumber, const QString &name = QString());
 
     /**
      * Remove the virtual desktop identified by id, if it exists
      * difference with setCount is that is possible to remove an arbitrary desktop,
      * not only the last one.
      * @param id the string id of the desktop to remove
      */
     void removeVirtualDesktop(const QByteArray &id);
 
     /**
      * Updates the net root info for new number of desktops
      **/
     void updateRootInfo();
 
     /**
      * @returns The maximum number of desktops that KWin supports.
      */
     static uint maximum();
 
 public Q_SLOTS:
     /**
      * Set the number of available desktops to @a count. This function overrides any previous
      * grid layout.
      * There needs to be at least one virtual desktop and the new value is capped at the maximum
      * number of desktops. A caller of this function cannot expect that the change has been applied.
      * It is the callers responsibility to either check the @link numberOfDesktops or connect to the
      * @link countChanged signal.
      *
      * In case the @link current desktop is on a desktop higher than the new count, the current desktop
      * is changed to be the new desktop with highest id. In that situation the signal @link desktopsRemoved
      * is emitted.
      * @param count The new number of desktops to use
      * @see count
      * @see maximum
      * @see countChanged
      * @see desktopsRemoved
      */
     void setCount(uint count);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      */
     bool setCurrent(uint current);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      **/
     bool setCurrent(VirtualDesktop *current);
     /**
      * Updates the layout to a new number of rows. The number of columns will be calculated accordingly
      */
     void setRows(uint rows);
     /**
      * Called from within setCount() to ensure the desktop layout is still valid.
      */
     void updateLayout();
     /**
      * @param enable wrapping around borders for navigation in desktop layout
      * @see isNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      **/
     void setNavigationWrappingAround(bool enabled);
     /**
      * Loads number of desktops and names from configuration file
      **/
     void load();
     /**
      * Saves number of desktops and names to configuration file
      **/
     void save();
 
 Q_SIGNALS:
     /**
      * Signal emitted whenever the number of virtual desktops changes.
      * @param previousCount The number of desktops prior to the change
      * @param newCount The new current number of desktops
      **/
     void countChanged(uint previousCount, uint newCount);
 
     /**
      * Signal when the number of rows in the layout changes
      * @param new number of rows
      */
     void rowsChanged(uint rows);
 
     /**
      * A new desktop has been created
      * @param desktop the new just crated desktop
      */
     void desktopCreated(KWin::VirtualDesktop *desktop);
 
     /**
      * A desktop has been removed and is about to be deleted
      * @param desktop the desktop that has been removed.
      *          It's guaranteed to stil la valid pointer when the signal arrives,
      *          but it's about to be deleted.
      */
     void desktopRemoved(KWin::VirtualDesktop *desktop);
 
     /**
      * Signal emitted whenever the current desktop changes.
      * @param previousDesktop The virtual desktop changed from
      * @param newDesktop The virtual desktop changed to
      **/
     void currentChanged(uint previousDesktop, uint newDesktop);
     /**
      * Signal emitted whenever the desktop layout changes.
      * @param columns The new number of columns in the layout
      * @param rows The new number of rows in the layout
      **/
     void layoutChanged(int columns, int rows);
     /**
      * Signal emitted whenever the navigationWrappingAround property changes.
      **/
     void navigationWrappingAroundChanged();
 
 private Q_SLOTS:
     /**
      * Common slot for all "Switch to Desktop n" shortcuts.
      * This method uses the sender() method to access some data.
      * DO NOT CALL DIRECTLY! ONLY TO BE USED FROM AN ACTION!
      **/
     void slotSwitchTo();
     /**
      * Slot for switch to next desktop action.
      **/
     void slotNext();
     /**
      * Slot for switch to previous desktop action.
      **/
     void slotPrevious();
     /**
      * Slot for switch to right desktop action.
      **/
     void slotRight();
     /**
      * Slot for switch to left desktop action.
      **/
     void slotLeft();
     /**
      * Slot for switch to desktop above action.
      **/
     void slotUp();
     /**
      * Slot for switch to desktop below action.
      **/
     void slotDown();
 
 private:
     /**
      * Generate a desktop layout from EWMH _NET_DESKTOP_LAYOUT property parameters.
      */
     void setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner);
     /**
      * @returns A default name for the given @p desktop
      **/
     QString defaultName(int desktop) const;
     /**
      * Creates all the global keyboard shortcuts for "Switch To Desktop n" actions.
      **/
     void initSwitchToShortcuts();
     /**
      * Creates an action and connects it to the @p slot in this Manager. This method is
      * meant to be used for the case that an additional information needs to be stored in
      * the action and the label.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param value An additional value added to the label and to the created action
      * @param key The global shortcut for the action
      * @param slot The slot to invoke when the action is triggered
      **/
     QAction *addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
     /**
      * Creates an action and connects it to the @p slot in this Manager.
      * Overloaded method for the case that no additional value needs to be passed to the action and
      * no global shortcut is defined by default.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param slot The slot to invoke when the action is triggered
      **/
     QAction *addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)());
 
     QVector<VirtualDesktop*> m_desktops;
     QPointer<VirtualDesktop> m_current;
     bool m_navigationWrapsAround;
     VirtualDesktopGrid m_grid;
     // TODO: QPointer
     NETRootInfo *m_rootInfo;
     KWayland::Server::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
     KSharedConfig::Ptr m_config;
     bool m_isLoading = false;
 
     KWIN_SINGLETON_VARIABLE(VirtualDesktopManager, s_manager)
 };
 
 /**
  * Function object to select the desktop above in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopAbove
 {
 public:
     DesktopAbove() {}
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns Id of the desktop above @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns the desktop above @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->above(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop below in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopBelow
 {
 public:
     DesktopBelow() {}
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns Id of the desktop below @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns the desktop below @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->below(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the left in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopLeft
 {
 public:
     DesktopLeft() {}
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns Id of the desktop left of @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns the desktop left of @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toLeft(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the right in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopRight
 {
 public:
     DesktopRight() {}
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns Id of the desktop right of @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns the desktop right of @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toRight(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the next desktop in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopNext
 {
 public:
     DesktopNext() {}
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns Id of the next desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns the next desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->next(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the previous desktop in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopPrevious
 {
 public:
     DesktopPrevious() {}
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns Id of the previous desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns the previous desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->previous(desktop, wrap);
     }
 };
 
 /**
  * Helper function to get the ID of a virtual desktop in the direction from
  * the given @p desktop. If @c 0 the current desktop is used as a starting point.
  * @param desktop The desktop from which the desktop in given Direction should be selected.
  * @param wrap Whether desktop navigation wraps around at the borders of the layout
  * @returns The next desktop in specified direction
  **/
 template <typename Direction>
 uint getDesktop(int desktop = 0, bool wrap = true);
 
 template <typename Direction>
 uint getDesktop(int d, bool wrap)
 {
     Direction direction;
     return direction(d, wrap);
 }
 
 inline
 int VirtualDesktopGrid::width() const
 {
     return m_size.width();
 }
 
 inline
 int VirtualDesktopGrid::height() const
 {
     return m_size.height();
 }
 
 inline
 const QSize &VirtualDesktopGrid::size() const
 {
     return m_size;
 }
 
 inline
 uint VirtualDesktopManager::maximum()
 {
     return 20;
 }
 
 inline
 uint VirtualDesktopManager::count() const
 {
     return m_desktops.count();
 }
 
 inline
 bool VirtualDesktopManager::isNavigationWrappingAround() const
 {
     return m_navigationWrapsAround;
 }
 
 inline
 void VirtualDesktopManager::setRootInfo(NETRootInfo *info)
 {
     m_rootInfo = info;
 }
 
 inline
 void VirtualDesktopManager::setConfig(KSharedConfig::Ptr config)
 {
     m_config = config;
 }
 
 inline
 const VirtualDesktopGrid &VirtualDesktopManager::grid() const
 {
     return m_grid;
 }
 
 template <typename Direction>
 void VirtualDesktopManager::moveTo(bool wrap)
 {
     Direction functor;
     setCurrent(functor(nullptr, wrap));
 }
 
 } // namespace KWin
 #endif