diff --git a/abstract_client.cpp b/abstract_client.cpp
index ec9a833ad..54afa586e 100644
--- a/abstract_client.cpp
+++ b/abstract_client.cpp
@@ -1,3302 +1,3397 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "abstract_client.h"
 
 #include "appmenu.h"
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationpalette.h"
 #include "decorations/decorationbridge.h"
 #include "cursor.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "outline.h"
 #include "screens.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "useractions.h"
 #include "workspace.h"
 
 #include "wayland_server.h"
 #include <KWaylandServer/plasmawindowmanagement_interface.h>
 
 #include <KDecoration2/Decoration>
 
 #include <KDesktopFile>
 
 #include <QMouseEvent>
 #include <QStyleHints>
 
 namespace KWin
 {
 
 static inline int sign(int v)
 {
     return (v > 0) - (v < 0);
 }
 
 QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> AbstractClient::s_palettes;
 std::shared_ptr<Decoration::DecorationPalette> AbstractClient::s_defaultPalette;
 
 AbstractClient::AbstractClient()
     : Toplevel()
 #ifdef KWIN_BUILD_TABBOX
     , m_tabBoxClient(QSharedPointer<TabBox::TabBoxClientImpl>(new TabBox::TabBoxClientImpl(this)))
 #endif
     , m_colorScheme(QStringLiteral("kdeglobals"))
 {
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::removeCheckScreenConnection);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::setupCheckScreenConnection);
 
     connect(this, &AbstractClient::paletteChanged, this, &AbstractClient::triggerDecorationRepaint);
 
     connect(Decoration::DecorationBridge::self(), &QObject::destroyed, this, &AbstractClient::destroyDecoration);
 
     // If the user manually moved the window, don't restore it after the keyboard closes
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged), this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, &AbstractClient::fullScreenChanged, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
 
     // replace on-screen-display on size changes
     connect(this, &AbstractClient::frameGeometryChanged, this,
         [this] (Toplevel *c, const QRect &old) {
             Q_UNUSED(c)
             if (isOnScreenDisplay() && !frameGeometry().isEmpty() && old.size() != frameGeometry().size() && !isInitialPositionSet()) {
                 GeometryUpdatesBlocker blocker(this);
                 const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
                 Placement::self()->place(this, area);
                 setGeometryRestore(frameGeometry());
             }
         }
     );
 
     connect(this, &AbstractClient::paddingChanged, this, [this]() {
         m_visibleRectBeforeGeometryUpdate = visibleRect();
     });
 
     connect(ApplicationMenu::self(), &ApplicationMenu::applicationMenuEnabledChanged, this, [this] {
         emit hasApplicationMenuChanged(hasApplicationMenu());
     });
 }
 
 AbstractClient::~AbstractClient()
 {
     Q_ASSERT(m_blockGeometryUpdates == 0);
     Q_ASSERT(m_decoration.decoration == nullptr);
 }
 
 void AbstractClient::updateMouseGrab()
 {
 }
 
 bool AbstractClient::belongToSameApplication(const AbstractClient *c1, const AbstractClient *c2, SameApplicationChecks checks)
 {
     return c1->belongsToSameApplication(c2, checks);
 }
 
 bool AbstractClient::isTransient() const
 {
     return false;
 }
 
 void AbstractClient::setClientShown(bool shown)
 {
     Q_UNUSED(shown)
 }
 
 xcb_timestamp_t AbstractClient::userTime() const
 {
     return XCB_TIME_CURRENT_TIME;
 }
 
 void AbstractClient::setSkipSwitcher(bool set)
 {
     set = rules()->checkSkipSwitcher(set);
     if (set == skipSwitcher())
         return;
     m_skipSwitcher = set;
     doSetSkipSwitcher();
     updateWindowRules(Rules::SkipSwitcher);
     emit skipSwitcherChanged();
 }
 
 void AbstractClient::setSkipPager(bool b)
 {
     b = rules()->checkSkipPager(b);
     if (b == skipPager())
         return;
     m_skipPager = b;
     doSetSkipPager();
     updateWindowRules(Rules::SkipPager);
     emit skipPagerChanged();
 }
 
 void AbstractClient::doSetSkipPager()
 {
 }
 
 void AbstractClient::setSkipTaskbar(bool b)
 {
     int was_wants_tab_focus = wantsTabFocus();
     if (b == skipTaskbar())
         return;
     m_skipTaskbar = b;
     doSetSkipTaskbar();
     updateWindowRules(Rules::SkipTaskbar);
     if (was_wants_tab_focus != wantsTabFocus()) {
         FocusChain::self()->update(this, isActive() ? FocusChain::MakeFirst : FocusChain::Update);
     }
     emit skipTaskbarChanged();
 }
 
 void AbstractClient::setOriginalSkipTaskbar(bool b)
 {
     m_originalSkipTaskbar = rules()->checkSkipTaskbar(b);
     setSkipTaskbar(m_originalSkipTaskbar);
 }
 
 void AbstractClient::doSetSkipTaskbar()
 {
 
 }
 
 void AbstractClient::doSetSkipSwitcher()
 {
 
 }
 
 void AbstractClient::setIcon(const QIcon &icon)
 {
     m_icon = icon;
     emit iconChanged();
 }
 
 void AbstractClient::setActive(bool act)
 {
     if (m_active == act) {
         return;
     }
     m_active = act;
     const int ruledOpacity = m_active
                              ? rules()->checkOpacityActive(qRound(opacity() * 100.0))
                              : rules()->checkOpacityInactive(qRound(opacity() * 100.0));
     setOpacity(ruledOpacity / 100.0);
     workspace()->setActiveClient(act ? this : nullptr);
 
     if (!m_active)
         cancelAutoRaise();
 
     if (!m_active && shadeMode() == ShadeActivated)
         setShade(ShadeNormal);
 
     StackingUpdatesBlocker blocker(workspace());
     workspace()->updateClientLayer(this);   // active windows may get different layer
     auto mainclients = mainClients();
     for (auto it = mainclients.constBegin();
             it != mainclients.constEnd();
             ++it)
         if ((*it)->isFullScreen())  // fullscreens go high even if their transient is active
             workspace()->updateClientLayer(*it);
 
     doSetActive();
     emit activeChanged();
     updateMouseGrab();
 }
 
 void AbstractClient::doSetActive()
 {
 }
 
 Layer AbstractClient::layer() const
 {
     if (m_layer == UnknownLayer)
         const_cast< AbstractClient* >(this)->m_layer = belongsToLayer();
     return m_layer;
 }
 
 void AbstractClient::updateLayer()
 {
     if (layer() == belongsToLayer())
         return;
     StackingUpdatesBlocker blocker(workspace());
     invalidateLayer(); // invalidate, will be updated when doing restacking
     for (auto it = transients().constBegin(),
                                   end = transients().constEnd(); it != end; ++it)
         (*it)->updateLayer();
 }
 
 void AbstractClient::placeIn(const QRect &area)
 {
     // TODO: Get rid of this method eventually. We need to call setGeometryRestore() because
     // checkWorkspacePosition() operates on geometryRestore() and because of quick tiling.
     Placement::self()->place(this, area);
     setGeometryRestore(frameGeometry());
 }
 
 void AbstractClient::invalidateLayer()
 {
     m_layer = UnknownLayer;
 }
 
 Layer AbstractClient::belongsToLayer() const
 {
     // NOTICE while showingDesktop, desktops move to the AboveLayer
     // (interchangeable w/ eg. yakuake etc. which will at first remain visible)
     // and the docks move into the NotificationLayer (which is between Above- and
     // ActiveLayer, so that active fullscreen windows will still cover everything)
     // Since the desktop is also activated, nothing should be in the ActiveLayer, though
     if (isInternal())
         return UnmanagedLayer;
     if (isDesktop())
         return workspace()->showingDesktop() ? AboveLayer : DesktopLayer;
     if (isSplash())          // no damn annoying splashscreens
         return NormalLayer; // getting in the way of everything else
     if (isDock()) {
         if (workspace()->showingDesktop())
             return NotificationLayer;
         return layerForDock();
     }
     if (isOnScreenDisplay())
         return OnScreenDisplayLayer;
     if (isNotification())
         return NotificationLayer;
     if (isCriticalNotification())
         return CriticalNotificationLayer;
     if (workspace()->showingDesktop() && belongsToDesktop()) {
         return AboveLayer;
     }
     if (keepBelow())
         return BelowLayer;
     if (isActiveFullScreen())
         return ActiveLayer;
     if (keepAbove())
         return AboveLayer;
 
     return NormalLayer;
 }
 
 bool AbstractClient::belongsToDesktop() const
 {
     return false;
 }
 
 Layer AbstractClient::layerForDock() const
 {
     // slight hack for the 'allow window to cover panel' Kicker setting
     // don't move keepbelow docks below normal window, but only to the same
     // layer, so that both may be raised to cover the other
     if (keepBelow())
         return NormalLayer;
     if (keepAbove()) // slight hack for the autohiding panels
         return AboveLayer;
     return DockLayer;
 }
 
 void AbstractClient::setKeepAbove(bool b)
 {
     b = rules()->checkKeepAbove(b);
     if (b && !rules()->checkKeepBelow(false))
         setKeepBelow(false);
     if (b == keepAbove()) {
         return;
     }
     m_keepAbove = b;
     doSetKeepAbove();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Above);
 
     emit keepAboveChanged(m_keepAbove);
 }
 
 void AbstractClient::doSetKeepAbove()
 {
 }
 
 void AbstractClient::setKeepBelow(bool b)
 {
     b = rules()->checkKeepBelow(b);
     if (b && !rules()->checkKeepAbove(false))
         setKeepAbove(false);
     if (b == keepBelow()) {
         return;
     }
     m_keepBelow = b;
     doSetKeepBelow();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Below);
 
     emit keepBelowChanged(m_keepBelow);
 }
 
 void AbstractClient::doSetKeepBelow()
 {
 }
 
 void AbstractClient::startAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = new QTimer(this);
     connect(m_autoRaiseTimer, &QTimer::timeout, this, &AbstractClient::autoRaise);
     m_autoRaiseTimer->setSingleShot(true);
     m_autoRaiseTimer->start(options->autoRaiseInterval());
 }
 
 void AbstractClient::cancelAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = nullptr;
 }
 
 void AbstractClient::autoRaise()
 {
     workspace()->raiseClient(this);
     cancelAutoRaise();
 }
 
 bool AbstractClient::wantsTabFocus() const
 {
     return (isNormalWindow() || isDialog()) && wantsInput();
 }
 
 bool AbstractClient::isSpecialWindow() const
 {
     // TODO
     return isDesktop() || isDock() || isSplash() || isToolbar() || isNotification() || isOnScreenDisplay() || isCriticalNotification();
 }
 
 void AbstractClient::demandAttention(bool set)
 {
     if (isActive())
         set = false;
     if (m_demandsAttention == set)
         return;
     m_demandsAttention = set;
     doSetDemandsAttention();
     workspace()->clientAttentionChanged(this, set);
     emit demandsAttentionChanged();
 }
 
 void AbstractClient::doSetDemandsAttention()
 {
 }
 
 void AbstractClient::setDesktop(int desktop)
 {
     const int numberOfDesktops = VirtualDesktopManager::self()->count();
     if (desktop != NET::OnAllDesktops)   // Do range check
         desktop = qMax(1, qMin(numberOfDesktops, desktop));
     desktop = qMin(numberOfDesktops, rules()->checkDesktop(desktop));
 
     QVector<VirtualDesktop *> desktops;
     if (desktop != NET::OnAllDesktops) {
        desktops << VirtualDesktopManager::self()->desktopForX11Id(desktop);
     }
     setDesktops(desktops);
 }
 
 void AbstractClient::setDesktops(QVector<VirtualDesktop*> desktops)
 {
     //on x11 we can have only one desktop at a time
     if (kwinApp()->operationMode() == Application::OperationModeX11 && desktops.size() > 1) {
         desktops = QVector<VirtualDesktop*>({desktops.last()});
     }
 
     if (desktops == m_desktops) {
         return;
     }
 
     int was_desk = AbstractClient::desktop();
     const bool wasOnCurrentDesktop = isOnCurrentDesktop() && was_desk >= 0;
 
     m_desktops = desktops;
 
     if (windowManagementInterface()) {
         if (m_desktops.isEmpty()) {
             windowManagementInterface()->setOnAllDesktops(true);
         } else {
             windowManagementInterface()->setOnAllDesktops(false);
             auto currentDesktops = windowManagementInterface()->plasmaVirtualDesktops();
             for (auto desktop: m_desktops) {
                 if (!currentDesktops.contains(desktop->id())) {
                     windowManagementInterface()->addPlasmaVirtualDesktop(desktop->id());
                 } else {
                     currentDesktops.removeOne(desktop->id());
                 }
             }
             for (auto desktopId: currentDesktops) {
                 windowManagementInterface()->removePlasmaVirtualDesktop(desktopId);
             }
         }
     }
     if (info) {
         info->setDesktop(desktop());
     }
 
     if ((was_desk == NET::OnAllDesktops) != (desktop() == NET::OnAllDesktops)) {
         // onAllDesktops changed
         workspace()->updateOnAllDesktopsOfTransients(this);
     }
 
     auto transients_stacking_order = workspace()->ensureStackingOrder(transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it)
         (*it)->setDesktops(desktops);
 
     if (isModal())  // if a modal dialog is moved, move the mainwindow with it as otherwise
         // the (just moved) modal dialog will confusingly return to the mainwindow with
         // the next desktop change
     {
         foreach (AbstractClient * c2, mainClients())
         c2->setDesktops(desktops);
     }
 
     doSetDesktop();
 
     FocusChain::self()->update(this, FocusChain::MakeFirst);
     updateWindowRules(Rules::Desktop);
 
     emit desktopChanged();
     if (wasOnCurrentDesktop != isOnCurrentDesktop())
         emit desktopPresenceChanged(this, was_desk);
     emit x11DesktopIdsChanged();
 }
 
 void AbstractClient::doSetDesktop()
 {
 }
 
 void AbstractClient::enterDesktop(VirtualDesktop *virtualDesktop)
 {
     if (m_desktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = m_desktops;
     desktops.append(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::leaveDesktop(VirtualDesktop *virtualDesktop)
 {
     QVector<VirtualDesktop*> currentDesktops;
     if (m_desktops.isEmpty()) {
         currentDesktops = VirtualDesktopManager::self()->desktops();
     } else {
         currentDesktops = m_desktops;
     }
 
     if (!currentDesktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = currentDesktops;
     desktops.removeOne(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::setOnAllDesktops(bool b)
 {
     if ((b && isOnAllDesktops()) ||
             (!b && !isOnAllDesktops()))
         return;
     if (b)
         setDesktop(NET::OnAllDesktops);
     else
         setDesktop(VirtualDesktopManager::self()->current());
 }
 
 QVector<uint> AbstractClient::x11DesktopIds() const
 {
     const auto desks = desktops();
     QVector<uint> x11Ids;
     x11Ids.reserve(desks.count());
     std::transform(desks.constBegin(), desks.constEnd(),
         std::back_inserter(x11Ids),
         [] (const VirtualDesktop *vd) {
             return vd->x11DesktopNumber();
         }
     );
     return x11Ids;
 }
 
+ShadeMode AbstractClient::shadeMode() const
+{
+    return m_shadeMode;
+}
+
 bool AbstractClient::isShadeable() const
 {
     return false;
 }
 
 void AbstractClient::setShade(bool set)
 {
     set ? setShade(ShadeNormal) : setShade(ShadeNone);
 }
 
 void AbstractClient::setShade(ShadeMode mode)
 {
-    Q_UNUSED(mode)
+    if (!isShadeable())
+        return;
+    if (mode == ShadeHover && isMove())
+        return; // causes geometry breaks and is probably nasty
+    if (isSpecialWindow() || noBorder())
+        mode = ShadeNone;
+
+    mode = rules()->checkShade(mode);
+    if (m_shadeMode == mode)
+        return;
+
+    const bool wasShade = isShade();
+    const ShadeMode previousShadeMode = shadeMode();
+    m_shadeMode = mode;
+
+    if (wasShade == isShade()) {
+        // Decoration may want to update after e.g. hover-shade changes
+        emit shadeChanged();
+        return; // No real change in shaded state
+    }
+
+    Q_ASSERT(isDecorated());
+    GeometryUpdatesBlocker blocker(this);
+
+    doSetShade(previousShadeMode);
+
+    discardWindowPixmap();
+    updateWindowRules(Rules::Shade);
+
+    emit shadeChanged();
 }
 
-ShadeMode AbstractClient::shadeMode() const
+void AbstractClient::doSetShade(ShadeMode previousShadeMode)
+{
+    Q_UNUSED(previousShadeMode)
+}
+
+void AbstractClient::shadeHover()
+{
+    setShade(ShadeHover);
+    cancelShadeHoverTimer();
+}
+
+void AbstractClient::shadeUnhover()
 {
-    return ShadeNone;
+    setShade(ShadeNormal);
+    cancelShadeHoverTimer();
+}
+
+void AbstractClient::startShadeHoverTimer()
+{
+    if (!isShade())
+        return;
+    m_shadeHoverTimer = new QTimer(this);
+    connect(m_shadeHoverTimer, &QTimer::timeout, this, &AbstractClient::shadeHover);
+    m_shadeHoverTimer->setSingleShot(true);
+    m_shadeHoverTimer->start(options->shadeHoverInterval());
+}
+
+void AbstractClient::startShadeUnhoverTimer()
+{
+    if (m_shadeMode == ShadeHover && !isMoveResize() && !isMoveResizePointerButtonDown()) {
+        m_shadeHoverTimer = new QTimer(this);
+        connect(m_shadeHoverTimer, &QTimer::timeout, this, &AbstractClient::shadeUnhover);
+        m_shadeHoverTimer->setSingleShot(true);
+        m_shadeHoverTimer->start(options->shadeHoverInterval());
+    }
+}
+
+void AbstractClient::cancelShadeHoverTimer()
+{
+    delete m_shadeHoverTimer;
+    m_shadeHoverTimer = nullptr;
+}
+
+void AbstractClient::toggleShade()
+{
+    // If the mode is ShadeHover or ShadeActive, cancel shade too.
+    setShade(shadeMode() == ShadeNone ? ShadeNormal : ShadeNone);
 }
 
 AbstractClient::Position AbstractClient::titlebarPosition() const
 {
     // TODO: still needed, remove?
     return PositionTop;
 }
 
 bool AbstractClient::titlebarPositionUnderMouse() const
 {
     if (!isDecorated()) {
         return false;
     }
     const auto sectionUnderMouse = decoration()->sectionUnderMouse();
     if (sectionUnderMouse == Qt::TitleBarArea) {
         return true;
     }
     // check other sections based on titlebarPosition
     switch (titlebarPosition()) {
     case AbstractClient::PositionTop:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::TopSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionLeft:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::LeftSection || sectionUnderMouse == Qt::BottomLeftSection);
     case AbstractClient::PositionRight:
         return (sectionUnderMouse == Qt::BottomRightSection || sectionUnderMouse == Qt::RightSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionBottom:
         return (sectionUnderMouse == Qt::BottomLeftSection || sectionUnderMouse == Qt::BottomSection || sectionUnderMouse == Qt::BottomRightSection);
     default:
         // nothing
         return false;
     }
 }
 
 void AbstractClient::setMinimized(bool set)
 {
     set ? minimize() : unminimize();
 }
 
 void AbstractClient::minimize(bool avoid_animation)
 {
     if (!isMinimizable() || isMinimized())
         return;
 
     m_minimized = true;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     FocusChain::self()->update(this, FocusChain::MakeFirstMinimized);
     // TODO: merge signal with s_minimized
     addWorkspaceRepaint(visibleRect());
     emit clientMinimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::unminimize(bool avoid_animation)
 {
     if (!isMinimized())
         return;
 
     if (rules()->checkMinimize(false)) {
         return;
     }
 
     m_minimized = false;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     emit clientUnminimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::doMinimize()
 {
 }
 
 QPalette AbstractClient::palette() const
 {
     if (!m_palette) {
         return QPalette();
     }
     return m_palette->palette();
 }
 
 const Decoration::DecorationPalette *AbstractClient::decorationPalette() const
 {
     return m_palette.get();
 }
 
 void AbstractClient::updateColorScheme(QString path)
 {
     if (path.isEmpty()) {
         path = QStringLiteral("kdeglobals");
     }
 
     if (!m_palette || m_colorScheme != path) {
         m_colorScheme = path;
 
         if (m_palette) {
             disconnect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
         }
 
         auto it = s_palettes.find(m_colorScheme);
 
         if (it == s_palettes.end() || it->expired()) {
             m_palette = std::make_shared<Decoration::DecorationPalette>(m_colorScheme);
             if (m_palette->isValid()) {
                 s_palettes[m_colorScheme] = m_palette;
             } else {
                 if (!s_defaultPalette) {
                     s_defaultPalette = std::make_shared<Decoration::DecorationPalette>(QStringLiteral("kdeglobals"));
                     s_palettes[QStringLiteral("kdeglobals")] = s_defaultPalette;
                 }
 
                 m_palette = s_defaultPalette;
             }
 
             if (m_colorScheme == QStringLiteral("kdeglobals")) {
                 s_defaultPalette = m_palette;
             }
         } else {
             m_palette = it->lock();
         }
 
         connect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
 
         emit paletteChanged(palette());
         emit colorSchemeChanged();
     }
 }
 
 void AbstractClient::handlePaletteChange()
 {
     emit paletteChanged(palette());
 }
 
 void AbstractClient::keepInArea(QRect area, bool partial)
 {
     if (partial) {
         // increase the area so that can have only 100 pixels in the area
         area.setLeft(qMin(area.left() - width() + 100, area.left()));
         area.setTop(qMin(area.top() - height() + 100, area.top()));
         area.setRight(qMax(area.right() + width() - 100, area.right()));
         area.setBottom(qMax(area.bottom() + height() - 100, area.bottom()));
     }
     if (!partial) {
         // resize to fit into area
         if (area.width() < width() || area.height() < height())
             resizeWithChecks(size().boundedTo(area.size()));
     }
     int tx = x(), ty = y();
     if (frameGeometry().right() > area.right() && width() <= area.width())
         tx = area.right() - width() + 1;
     if (frameGeometry().bottom() > area.bottom() && height() <= area.height())
         ty = area.bottom() - height() + 1;
     if (!area.contains(frameGeometry().topLeft())) {
         if (tx < area.x())
             tx = area.x();
         if (ty < area.y())
             ty = area.y();
     }
     if (tx != x() || ty != y())
         move(tx, ty);
 }
 
 /**
  * Returns the maximum client size, not the maximum frame size.
  */
 QSize AbstractClient::maxSize() const
 {
     return rules()->checkMaxSize(QSize(INT_MAX, INT_MAX));
 }
 
 /**
  * Returns the minimum client size, not the minimum frame size.
  */
 QSize AbstractClient::minSize() const
 {
     return rules()->checkMinSize(QSize(0, 0));
 }
 
 void AbstractClient::blockGeometryUpdates(bool block)
 {
     if (block) {
         if (m_blockGeometryUpdates == 0)
             m_pendingGeometryUpdate = PendingGeometryNone;
         ++m_blockGeometryUpdates;
     } else {
         if (--m_blockGeometryUpdates == 0) {
             if (m_pendingGeometryUpdate != PendingGeometryNone) {
                 if (isShade())
                     setFrameGeometry(QRect(pos(), adjustedSize()), NormalGeometrySet);
                 else
                     setFrameGeometry(frameGeometry(), NormalGeometrySet);
                 m_pendingGeometryUpdate = PendingGeometryNone;
             }
         }
     }
 }
 
 void AbstractClient::maximize(MaximizeMode m)
 {
     setMaximize(m & MaximizeVertical, m & MaximizeHorizontal);
 }
 
 void AbstractClient::setMaximize(bool vertically, bool horizontally)
 {
     // changeMaximize() flips the state, so change from set->flip
     const MaximizeMode oldMode = maximizeMode();
     changeMaximize(
         oldMode & MaximizeHorizontal ? !horizontally : horizontally,
         oldMode & MaximizeVertical ? !vertically : vertically,
         false);
     const MaximizeMode newMode = maximizeMode();
     if (oldMode != newMode) {
         emit clientMaximizedStateChanged(this, newMode);
         emit clientMaximizedStateChanged(this, vertically, horizontally);
     }
 }
 
 void AbstractClient::move(int x, int y, ForceGeometry_t force)
 {
     // resuming geometry updates is handled only in setGeometry()
     Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
     QPoint p(x, y);
     if (!areGeometryUpdatesBlocked() && p != rules()->checkPosition(p)) {
         qCDebug(KWIN_CORE) << "forced position fail:" << p << ":" << rules()->checkPosition(p);
     }
     if (force == NormalGeometrySet && m_frameGeometry.topLeft() == p)
         return;
     m_frameGeometry.moveTopLeft(p);
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     doMove(x, y);
     updateWindowRules(Rules::Position);
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
     // client itself is not damaged
     emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 bool AbstractClient::startMoveResize()
 {
     Q_ASSERT(!isMoveResize());
     Q_ASSERT(QWidget::keyboardGrabber() == nullptr);
     Q_ASSERT(QWidget::mouseGrabber() == nullptr);
     stopDelayedMoveResize();
     if (QApplication::activePopupWidget() != nullptr)
         return false; // popups have grab
     if (isFullScreen() && (screens()->count() < 2 || !isMovableAcrossScreens()))
         return false;
     if (!doStartMoveResize()) {
         return false;
     }
 
     invalidateDecorationDoubleClickTimer();
 
     setMoveResize(true);
     workspace()->setMoveResizeClient(this);
 
     const Position mode = moveResizePointerMode();
     if (mode != PositionCenter) { // means "isResize()" but moveResizeMode = true is set below
         if (maximizeMode() == MaximizeFull) { // partial is cond. reset in finishMoveResize
             setGeometryRestore(frameGeometry()); // "restore" to current geometry
             setMaximize(false, false);
         }
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet
         // Exit quick tile mode when the user attempts to resize a tiled window
         updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry
         setGeometryRestore(frameGeometry());
         emit quickTileModeChanged();
     }
 
     updateHaveResizeEffect();
     updateInitialMoveResizeGeometry();
     checkUnrestrictedMoveResize();
     emit clientStartUserMovedResized(this);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(true, Qt::Vertical|Qt::Horizontal);
     return true;
 }
 
 void AbstractClient::finishMoveResize(bool cancel)
 {
     GeometryUpdatesBlocker blocker(this);
     const bool wasResize = isResize(); // store across leaveMoveResize
     leaveMoveResize();
 
     if (cancel)
         setFrameGeometry(initialMoveResizeGeometry());
     else {
         const QRect &moveResizeGeom = moveResizeGeometry();
         if (wasResize) {
             const bool restoreH = maximizeMode() == MaximizeHorizontal &&
                                     moveResizeGeom.width() != initialMoveResizeGeometry().width();
             const bool restoreV = maximizeMode() == MaximizeVertical &&
                                     moveResizeGeom.height() != initialMoveResizeGeometry().height();
             if (restoreH || restoreV) {
                 changeMaximize(restoreH, restoreV, false);
             }
         }
         setFrameGeometry(moveResizeGeom);
     }
     checkScreen(); // needs to be done because clientFinishUserMovedResized has not yet re-activated online alignment
     if (screen() != moveResizeStartScreen()) {
         workspace()->sendClientToScreen(this, screen()); // checks rule validity
         if (maximizeMode() != MaximizeRestore)
             checkWorkspacePosition();
     }
 
     if (isElectricBorderMaximizing()) {
         setQuickTileMode(electricBorderMode());
         setElectricBorderMaximizing(false);
     } else if (!cancel) {
         QRect geom_restore = geometryRestore();
         if (!(maximizeMode() & MaximizeHorizontal)) {
             geom_restore.setX(frameGeometry().x());
             geom_restore.setWidth(frameGeometry().width());
         }
         if (!(maximizeMode() & MaximizeVertical)) {
             geom_restore.setY(frameGeometry().y());
             geom_restore.setHeight(frameGeometry().height());
         }
         setGeometryRestore(geom_restore);
     }
 // FRAME    update();
 
     emit clientFinishUserMovedResized(this);
 }
 
 // This function checks if it actually makes sense to perform a restricted move/resize.
 // If e.g. the titlebar is already outside of the workarea, there's no point in performing
 // a restricted move resize, because then e.g. resize would also move the window (#74555).
 // NOTE: Most of it is duplicated from handleMoveResize().
 void AbstractClient::checkUnrestrictedMoveResize()
 {
     if (isUnrestrictedMoveResize())
         return;
     const QRect &moveResizeGeom = moveResizeGeometry();
     QRect desktopArea = workspace()->clientArea(WorkArea, moveResizeGeom.center(), desktop());
     int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
     // restricted move/resize - keep at least part of the titlebar always visible
     // how much must remain visible when moved away in that direction
     left_marge = qMin(100 + borderRight(), moveResizeGeom.width());
     right_marge = qMin(100 + borderLeft(), moveResizeGeom.width());
     // width/height change with opaque resizing, use the initial ones
     titlebar_marge = initialMoveResizeGeometry().height();
     top_marge = borderBottom();
     bottom_marge = borderTop();
     if (isResize()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + top_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
         if (!isUnrestrictedMoveResize() && moveResizeGeom.top() < desktopArea.top())   // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
     }
     if (isMove()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1)
             setUnrestrictedMoveResize(true);
         // no need to check top_marge, titlebar_marge already handles it
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge + 1) // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
     }
 }
 
 // When the user pressed mouse on the titlebar, don't activate move immediatelly,
 // since it may be just a click. Activate instead after a delay. Move used to be
 // activated only after moving by several pixels, but that looks bad.
 void AbstractClient::startDelayedMoveResize()
 {
     Q_ASSERT(!m_moveResize.delayedTimer);
     m_moveResize.delayedTimer = new QTimer(this);
     m_moveResize.delayedTimer->setSingleShot(true);
     connect(m_moveResize.delayedTimer, &QTimer::timeout, this,
         [this]() {
             Q_ASSERT(isMoveResizePointerButtonDown());
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
             }
             updateCursor();
             stopDelayedMoveResize();
         }
     );
     m_moveResize.delayedTimer->start(QApplication::startDragTime());
 }
 
 void AbstractClient::stopDelayedMoveResize()
 {
     delete m_moveResize.delayedTimer;
     m_moveResize.delayedTimer = nullptr;
 }
 
 void AbstractClient::updateMoveResize(const QPointF &currentGlobalCursor)
 {
     handleMoveResize(pos(), currentGlobalCursor.toPoint());
 }
 
 void AbstractClient::handleMoveResize(const QPoint &local, const QPoint &global)
 {
     const QRect oldGeo = frameGeometry();
     handleMoveResize(local.x(), local.y(), global.x(), global.y());
     if (!isFullScreen() && isMove()) {
         if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != frameGeometry()) {
             GeometryUpdatesBlocker blocker(this);
             setQuickTileMode(QuickTileFlag::None);
             const QRect &geom_restore = geometryRestore();
             setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()),
                                  double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height())));
             if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore)
                 setMoveResizeGeometry(geom_restore);
             handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) {
             checkQuickTilingMaximizationZones(global.x(), global.y());
         }
     }
 }
 
 void AbstractClient::handleMoveResize(int x, int y, int x_root, int y_root)
 {
     if (isWaitingForMoveResizeSync())
         return; // we're still waiting for the client or the timeout
 
     const Position mode = moveResizePointerMode();
     if ((mode == PositionCenter && !isMovableAcrossScreens())
             || (mode != PositionCenter && (isShade() || !isResizable())))
         return;
 
     if (!isMoveResize()) {
         QPoint p(QPoint(x/* - padding_left*/, y/* - padding_top*/) - moveOffset());
         if (p.manhattanLength() >= QApplication::startDragDistance()) {
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
                 updateCursor();
                 return;
             }
             updateCursor();
         } else
             return;
     }
 
     // ShadeHover or ShadeActive, ShadeNormal was already avoided above
     if (mode != PositionCenter && shadeMode() != ShadeNone)
         setShade(ShadeNone);
 
     QPoint globalPos(x_root, y_root);
     // these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
     // the bottomleft corner should be at is at (topleft.x(), bottomright().y())
     QPoint topleft = globalPos - moveOffset();
     QPoint bottomright = globalPos + invertedMoveOffset();
     QRect previousMoveResizeGeom = moveResizeGeometry();
 
     // TODO move whole group when moving its leader or when the leader is not mapped?
 
     auto titleBarRect = [this](bool &transposed, int &requiredPixels) -> QRect {
         const QRect &moveResizeGeom = moveResizeGeometry();
         QRect r(moveResizeGeom);
         r.moveTopLeft(QPoint(0,0));
         switch (titlebarPosition()) {
         default:
         case PositionTop:
             r.setHeight(borderTop());
             break;
         case PositionLeft:
             r.setWidth(borderLeft());
             transposed = true;
             break;
         case PositionBottom:
             r.setTop(r.bottom() - borderBottom());
             break;
         case PositionRight:
             r.setLeft(r.right() - borderRight());
             transposed = true;
             break;
         }
         // When doing a restricted move we must always keep 100px of the titlebar
         // visible to allow the user to be able to move it again.
         requiredPixels = qMin(100 * (transposed ? r.width() : r.height()),
                               moveResizeGeom.width() * moveResizeGeom.height());
         return r;
     };
 
     bool update = false;
     if (isResize()) {
         QRect orig = initialMoveResizeGeometry();
         SizeMode sizeMode = SizeModeAny;
         auto calculateMoveResizeGeom = [this, &topleft, &bottomright, &orig, &sizeMode, &mode]() {
             switch(mode) {
             case PositionTopLeft:
                 setMoveResizeGeometry(QRect(topleft, orig.bottomRight()));
                 break;
             case PositionBottomRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), bottomright));
                 break;
             case PositionBottomLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.y()), QPoint(orig.right(), bottomright.y())));
                 break;
             case PositionTopRight:
                 setMoveResizeGeometry(QRect(QPoint(orig.x(), topleft.y()), QPoint(bottomright.x(), orig.bottom())));
                 break;
             case PositionTop:
                 setMoveResizeGeometry(QRect(QPoint(orig.left(), topleft.y()), orig.bottomRight()));
                 sizeMode = SizeModeFixedH; // try not to affect height
                 break;
             case PositionBottom:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(orig.right(), bottomright.y())));
                 sizeMode = SizeModeFixedH;
                 break;
             case PositionLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.top()), orig.bottomRight()));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(bottomright.x(), orig.bottom())));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionCenter:
             default:
                 abort();
                 break;
             }
         };
 
         // first resize (without checking constrains), then snap, then check bounds, then check constrains
         calculateMoveResizeGeom();
         // adjust new size to snap to other windows/borders
         setMoveResizeGeometry(workspace()->adjustClientSize(this, moveResizeGeometry(), mode));
 
         if (!isUnrestrictedMoveResize()) {
             // Make sure the titlebar isn't behind a restricted area. We don't need to restrict
             // the other directions. If not visible enough, move the window to the closest valid
             // point. We bruteforce this by slowly moving the window back to its previous position
             QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
             availableArea -= workspace()->restrictedMoveArea(desktop());   // Strut areas
             bool transposed = false;
             int requiredPixels;
             QRect bTitleRect = titleBarRect(transposed, requiredPixels);
             int lastVisiblePixels = -1;
             QRect lastTry = moveResizeGeometry();
             bool titleFailed = false;
             for (;;) {
                 const QRect titleRect(bTitleRect.translated(moveResizeGeometry().topLeft()));
                 int visiblePixels = 0;
                 int realVisiblePixels = 0;
                 for (const QRect &rect : availableArea) {
                     const QRect r = rect & titleRect;
                     realVisiblePixels += r.width() * r.height();
                     if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                         (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                         visiblePixels += r.width() * r.height();
                 }
 
                 if (visiblePixels >= requiredPixels)
                     break; // We have reached a valid position
 
                 if (realVisiblePixels <= lastVisiblePixels) {
                     if (titleFailed && realVisiblePixels < lastVisiblePixels)
                         break; // we won't become better
                     else {
                         if (!titleFailed)
                             setMoveResizeGeometry(lastTry);
                         titleFailed = true;
                     }
                 }
                 lastVisiblePixels = realVisiblePixels;
                 QRect moveResizeGeom = moveResizeGeometry();
                 lastTry = moveResizeGeom;
 
                 // Not visible enough, move the window to the closest valid point. We bruteforce
                 // this by slowly moving the window back to its previous position.
                 // The geometry changes at up to two edges, the one with the title (if) shall take
                 // precedence. The opposing edge has no impact on visiblePixels and only one of
                 // the adjacent can alter at a time, ie. it's enough to ignore adjacent edges
                 // if the title edge altered
                 bool leftChanged  = previousMoveResizeGeom.left()   != moveResizeGeom.left();
                 bool rightChanged = previousMoveResizeGeom.right()  != moveResizeGeom.right();
                 bool topChanged   = previousMoveResizeGeom.top()    != moveResizeGeom.top();
                 bool btmChanged   = previousMoveResizeGeom.bottom() != moveResizeGeom.bottom();
                 auto fixChangedState = [titleFailed](bool &major, bool &counter, bool &ad1, bool &ad2) {
                     counter = false;
                     if (titleFailed)
                         major = false;
                     if (major)
                         ad1 = ad2 = false;
                 };
                 switch (titlebarPosition()) {
                 default:
                 case PositionTop:
                     fixChangedState(topChanged, btmChanged, leftChanged, rightChanged);
                     break;
                 case PositionLeft:
                     fixChangedState(leftChanged, rightChanged, topChanged, btmChanged);
                     break;
                 case PositionBottom:
                     fixChangedState(btmChanged, topChanged, leftChanged, rightChanged);
                     break;
                 case PositionRight:
                     fixChangedState(rightChanged, leftChanged, topChanged, btmChanged);
                     break;
                 }
                 if (topChanged)
                     moveResizeGeom.setTop(moveResizeGeom.y() + sign(previousMoveResizeGeom.y() - moveResizeGeom.y()));
                 else if (leftChanged)
                     moveResizeGeom.setLeft(moveResizeGeom.x() + sign(previousMoveResizeGeom.x() - moveResizeGeom.x()));
                 else if (btmChanged)
                     moveResizeGeom.setBottom(moveResizeGeom.bottom() + sign(previousMoveResizeGeom.bottom() - moveResizeGeom.bottom()));
                 else if (rightChanged)
                     moveResizeGeom.setRight(moveResizeGeom.right() + sign(previousMoveResizeGeom.right() - moveResizeGeom.right()));
                 else
                     break; // no position changed - that's certainly not good
                 setMoveResizeGeometry(moveResizeGeom);
             }
         }
 
         // Always obey size hints, even when in "unrestricted" mode
         QSize size = constrainFrameSize(moveResizeGeometry().size(), sizeMode);
         // the new topleft and bottomright corners (after checking size constrains), if they'll be needed
         topleft = QPoint(moveResizeGeometry().right() - size.width() + 1, moveResizeGeometry().bottom() - size.height() + 1);
         bottomright = QPoint(moveResizeGeometry().left() + size.width() - 1, moveResizeGeometry().top() + size.height() - 1);
         orig = moveResizeGeometry();
 
         // if aspect ratios are specified, both dimensions may change.
         // Therefore grow to the right/bottom if needed.
         // TODO it should probably obey gravity rather than always using right/bottom ?
         if (sizeMode == SizeModeFixedH)
             orig.setRight(bottomright.x());
         else if (sizeMode == SizeModeFixedW)
             orig.setBottom(bottomright.y());
 
         calculateMoveResizeGeom();
 
         if (moveResizeGeometry().size() != previousMoveResizeGeom.size())
             update = true;
     } else if (isMove()) {
         Q_ASSERT(mode == PositionCenter);
         if (!isMovable()) { // isMovableAcrossScreens() must have been true to get here
             // Special moving of maximized windows on Xinerama screens
             int screen = screens()->number(globalPos);
             if (isFullScreen())
                 setMoveResizeGeometry(workspace()->clientArea(FullScreenArea, screen, 0));
             else {
                 QRect moveResizeGeom = workspace()->clientArea(MaximizeArea, screen, 0);
                 QSize adjSize = constrainFrameSize(moveResizeGeom.size(), SizeModeMax);
                 if (adjSize != moveResizeGeom.size()) {
                     QRect r(moveResizeGeom);
                     moveResizeGeom.setSize(adjSize);
                     moveResizeGeom.moveCenter(r.center());
                 }
                 setMoveResizeGeometry(moveResizeGeom);
             }
         } else {
             // first move, then snap, then check bounds
             QRect moveResizeGeom = moveResizeGeometry();
             moveResizeGeom.moveTopLeft(topleft);
             moveResizeGeom.moveTopLeft(workspace()->adjustClientPosition(this, moveResizeGeom.topLeft(),
                                        isUnrestrictedMoveResize()));
             setMoveResizeGeometry(moveResizeGeom);
 
             if (!isUnrestrictedMoveResize()) {
                 const QRegion strut = workspace()->restrictedMoveArea(desktop());   // Strut areas
                 QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
                 availableArea -= strut;   // Strut areas
                 bool transposed = false;
                 int requiredPixels;
                 QRect bTitleRect = titleBarRect(transposed, requiredPixels);
                 for (;;) {
                     QRect moveResizeGeom = moveResizeGeometry();
                     const QRect titleRect(bTitleRect.translated(moveResizeGeom.topLeft()));
                     int visiblePixels = 0;
                     for (const QRect &rect : availableArea) {
                         const QRect r = rect & titleRect;
                         if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                             (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                             visiblePixels += r.width() * r.height();
                     }
                     if (visiblePixels >= requiredPixels)
                         break; // We have reached a valid position
 
                     // (esp.) if there're more screens with different struts (panels) it the titlebar
                     // will be movable outside the movearea (covering one of the panels) until it
                     // crosses the panel "too much" (not enough visiblePixels) and then stucks because
                     // it's usually only pushed by 1px to either direction
                     // so we first check whether we intersect suc strut and move the window below it
                     // immediately (it's still possible to hit the visiblePixels >= titlebarArea break
                     // by moving the window slightly downwards, but it won't stuck)
                     // see bug #274466
                     // and bug #301805 for why we can't just match the titlearea against the screen
                     if (screens()->count() > 1) { // optimization
                         // TODO: could be useful on partial screen struts (half-width panels etc.)
                         int newTitleTop = -1;
                         for (const QRect &r : strut) {
                             if (r.top() == 0 && r.width() > r.height() && // "top panel"
                                 r.intersects(moveResizeGeom) && moveResizeGeom.top() < r.bottom()) {
                                 newTitleTop = r.bottom() + 1;
                                 break;
                             }
                         }
                         if (newTitleTop > -1) {
                             moveResizeGeom.moveTop(newTitleTop); // invalid position, possibly on screen change
                             setMoveResizeGeometry(moveResizeGeom);
                             break;
                         }
                     }
 
                     int dx = sign(previousMoveResizeGeom.x() - moveResizeGeom.x()),
                         dy = sign(previousMoveResizeGeom.y() - moveResizeGeom.y());
                     if (visiblePixels && dx) // means there's no full width cap -> favor horizontally
                         dy = 0;
                     else if (dy)
                         dx = 0;
 
                     // Move it back
                     moveResizeGeom.translate(dx, dy);
                     setMoveResizeGeometry(moveResizeGeom);
 
                     if (moveResizeGeom == previousMoveResizeGeom) {
                         break; // Prevent lockup
                     }
                 }
             }
         }
         if (moveResizeGeometry().topLeft() != previousMoveResizeGeom.topLeft())
             update = true;
     } else
         abort();
 
     if (!update)
         return;
 
     if (isResize() && !haveResizeEffect()) {
         doResizeSync();
     } else
         performMoveResize();
 
     if (isMove()) {
         ScreenEdges::self()->check(globalPos, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC));
     }
 }
 
 void AbstractClient::performMoveResize()
 {
     const QRect &moveResizeGeom = moveResizeGeometry();
     if (isMove() || (isResize() && !haveResizeEffect())) {
         setFrameGeometry(moveResizeGeom);
     }
     doPerformMoveResize();
     positionGeometryTip();
     emit clientStepUserMovedResized(this, moveResizeGeom);
 }
 
 bool AbstractClient::hasStrut() const
 {
     return false;
 }
 
 void AbstractClient::setupWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         // already setup
         return;
     }
     if (!waylandServer() || !surface()) {
         return;
     }
     if (!waylandServer()->windowManagement()) {
         return;
     }
     using namespace KWaylandServer;
     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->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
     w->setIcon(icon());
     auto updateAppId = [this, w] {
         w->setAppId(QString::fromUtf8(m_desktopFileName.isEmpty() ? resourceClass() : m_desktopFileName));
     };
     updateAppId();
     w->setSkipTaskbar(skipTaskbar());
     w->setSkipSwitcher(skipSwitcher());
     w->setPid(pid());
     w->setShadeable(isShadeable());
     w->setShaded(isShade());
     w->setResizable(isResizable());
     w->setMovable(isMovable());
     w->setVirtualDesktopChangeable(true); // FIXME Matches X11Client::actionSupported(), but both should be implemented.
     w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
     w->setGeometry(frameGeometry());
     connect(this, &AbstractClient::skipTaskbarChanged, w,
         [w, this] {
             w->setSkipTaskbar(skipTaskbar());
         }
     );
     connect(this, &AbstractClient::skipSwitcherChanged, w,
          [w, this] {
             w->setSkipSwitcher(skipSwitcher());
         }
     );
     connect(this, &AbstractClient::captionChanged, w, [w, this] { w->setTitle(caption()); });
 
     connect(this, &AbstractClient::activeChanged, w, [w, this] { w->setActive(isActive()); });
     connect(this, &AbstractClient::fullScreenChanged, w, [w, this] { w->setFullscreen(isFullScreen()); });
     connect(this, &AbstractClient::keepAboveChanged, w, &PlasmaWindowInterface::setKeepAbove);
     connect(this, &AbstractClient::keepBelowChanged, w, &PlasmaWindowInterface::setKeepBelow);
     connect(this, &AbstractClient::minimizedChanged, w, [w, this] { w->setMinimized(isMinimized()); });
     connect(this, static_cast<void (AbstractClient::*)(AbstractClient*,MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged), w,
         [w] (KWin::AbstractClient *c, MaximizeMode mode) {
             Q_UNUSED(c);
             w->setMaximized(mode == KWin::MaximizeFull);
         }
     );
     connect(this, &AbstractClient::demandsAttentionChanged, w, [w, this] { w->setDemandsAttention(isDemandingAttention()); });
     connect(this, &AbstractClient::iconChanged, w,
         [w, this] {
             w->setIcon(icon());
         }
     );
     connect(this, &AbstractClient::windowClassChanged, w, updateAppId);
     connect(this, &AbstractClient::desktopFileNameChanged, w, updateAppId);
     connect(this, &AbstractClient::shadeChanged, w, [w, this] { w->setShaded(isShade()); });
     connect(this, &AbstractClient::transientChanged, w,
         [w, this] {
             w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
         }
     );
     connect(this, &AbstractClient::frameGeometryChanged, w,
         [w, this] {
             w->setGeometry(frameGeometry());
         }
     );
     connect(this, &AbstractClient::applicationMenuChanged, w,
         [w, this] {
             w->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
         }
     );
     connect(w, &PlasmaWindowInterface::closeRequested, this, [this] { closeWindow(); });
     connect(w, &PlasmaWindowInterface::moveRequested, this,
         [this] {
             Cursors::self()->mouse()->setPos(frameGeometry().center());
             performMouseCommand(Options::MouseMove, Cursors::self()->mouse()->pos());
         }
     );
     connect(w, &PlasmaWindowInterface::resizeRequested, this,
         [this] {
             Cursors::self()->mouse()->setPos(frameGeometry().bottomRight());
             performMouseCommand(Options::MouseResize, Cursors::self()->mouse()->pos());
         }
     );
     connect(w, &PlasmaWindowInterface::virtualDesktopRequested, this,
         [this] (quint32 desktop) {
             workspace()->sendClientToDesktop(this, desktop + 1, true);
         }
     );
     connect(w, &PlasmaWindowInterface::fullscreenRequested, this,
         [this] (bool set) {
             setFullScreen(set, false);
         }
     );
     connect(w, &PlasmaWindowInterface::minimizedRequested, this,
         [this] (bool set) {
             if (set) {
                 minimize();
             } else {
                 unminimize();
             }
         }
     );
     connect(w, &PlasmaWindowInterface::maximizedRequested, this,
         [this] (bool set) {
             maximize(set ? MaximizeFull : MaximizeRestore);
         }
     );
     connect(w, &PlasmaWindowInterface::keepAboveRequested, this,
         [this] (bool set) {
             setKeepAbove(set);
         }
     );
     connect(w, &PlasmaWindowInterface::keepBelowRequested, this,
         [this] (bool set) {
             setKeepBelow(set);
         }
     );
     connect(w, &PlasmaWindowInterface::demandsAttentionRequested, this,
         [this] (bool set) {
             demandAttention(set);
         }
     );
     connect(w, &PlasmaWindowInterface::activeRequested, this,
         [this] (bool set) {
             if (set) {
                 workspace()->activateClient(this, true);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::shadedRequested, this,
         [this] (bool set) {
             setShade(set);
         }
     );
 
     for (const auto vd : m_desktops) {
         w->addPlasmaVirtualDesktop(vd->id());
     }
 
     //this is only for the legacy
     connect(this, &AbstractClient::desktopChanged, w,
         [w, this] {
             if (isOnAllDesktops()) {
                 w->setOnAllDesktops(true);
                 return;
             }
             w->setVirtualDesktop(desktop() - 1);
             w->setOnAllDesktops(false);
         }
     );
 
     //Plasma Virtual desktop management
     //show/hide when the window enters/exits from desktop
     connect(w, &PlasmaWindowInterface::enterPlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 enterDesktop(vd);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::enterNewPlasmaVirtualDesktopRequested, this,
         [this] () {
             VirtualDesktopManager::self()->setCount(VirtualDesktopManager::self()->count() + 1);
             enterDesktop(VirtualDesktopManager::self()->desktops().last());
         }
     );
     connect(w, &PlasmaWindowInterface::leavePlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 leaveDesktop(vd);
             }
         }
     );
 
     m_windowManagementInterface = w;
 }
 
 void AbstractClient::destroyWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         m_windowManagementInterface->unmap();
         m_windowManagementInterface = nullptr;
     }
 }
 
 Options::MouseCommand AbstractClient::getMouseCommand(Qt::MouseButton button, bool *handled) const
 {
     *handled = false;
     if (button == Qt::NoButton) {
         return Options::MouseNothing;
     }
     if (isActive()) {
         if (options->isClickRaise()) {
             *handled = true;
             return Options::MouseActivateRaiseAndPassClick;
         }
     } else {
         *handled = true;
         switch (button) {
         case Qt::LeftButton:
             return options->commandWindow1();
         case Qt::MiddleButton:
             return options->commandWindow2();
         case Qt::RightButton:
             return options->commandWindow3();
         default:
             // all other buttons pass Activate & Pass Client
             return Options::MouseActivateAndPassClick;
         }
     }
     return Options::MouseNothing;
 }
 
 Options::MouseCommand AbstractClient::getWheelCommand(Qt::Orientation orientation, bool *handled) const
 {
     *handled = false;
     if (orientation != Qt::Vertical) {
         return Options::MouseNothing;
     }
     if (!isActive()) {
         *handled = true;
         return options->commandWindowWheel();
     }
     return Options::MouseNothing;
 }
 
 bool AbstractClient::performMouseCommand(Options::MouseCommand cmd, const QPoint &globalPos)
 {
     bool replay = false;
     switch(cmd) {
     case Options::MouseRaise:
         workspace()->raiseClient(this);
         break;
     case Options::MouseLower: {
         workspace()->lowerClient(this);
         // used to be activateNextClient(this), then topClientOnDesktop
         // since this is a mouseOp it's however safe to use the client under the mouse instead
         if (isActive() && options->focusPolicyIsReasonable()) {
             AbstractClient *next = workspace()->clientUnderMouse(screen());
             if (next && next != this)
                 workspace()->requestFocus(next, false);
         }
         break;
     }
     case Options::MouseOperationsMenu:
         if (isActive() && options->isClickRaise())
             autoRaise();
         workspace()->showWindowMenu(QRect(globalPos, globalPos), this);
         break;
     case Options::MouseToggleRaiseAndLower:
         workspace()->raiseOrLowerClient(this);
         break;
     case Options::MouseActivateAndRaise: {
         replay = isActive(); // for clickraise mode
         bool mustReplay = !rules()->checkAcceptFocus(acceptsFocus());
         if (mustReplay) {
             auto it = workspace()->stackingOrder().constEnd(),
                                      begin = workspace()->stackingOrder().constBegin();
             while (mustReplay && --it != begin && *it != this) {
                 AbstractClient *c = qobject_cast<AbstractClient*>(*it);
                 if (!c || (c->keepAbove() && !keepAbove()) || (keepBelow() && !c->keepBelow()))
                     continue; // can never raise above "it"
                 mustReplay = !(c->isOnCurrentDesktop() && c->isOnCurrentActivity() && c->frameGeometry().intersects(frameGeometry()));
             }
         }
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = replay || mustReplay;
         break;
     }
     case Options::MouseActivateAndLower:
         workspace()->requestFocus(this);
         workspace()->lowerClient(this);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivate:
         replay = isActive(); // for clickraise mode
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivateRaiseAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseActivateAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseMaximize:
         maximize(MaximizeFull);
         break;
     case Options::MouseRestore:
         maximize(MaximizeRestore);
         break;
     case Options::MouseMinimize:
         minimize();
         break;
     case Options::MouseAbove: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepBelow())
             setKeepBelow(false);
         else
             setKeepAbove(true);
         break;
     }
     case Options::MouseBelow: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepAbove())
             setKeepAbove(false);
         else
             setKeepBelow(true);
         break;
     }
     case Options::MousePreviousDesktop:
         workspace()->windowToPreviousDesktop(this);
         break;
     case Options::MouseNextDesktop:
         workspace()->windowToNextDesktop(this);
         break;
     case Options::MouseOpacityMore:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMin(opacity() + 0.1, 1.0));
         break;
     case Options::MouseOpacityLess:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMax(opacity() - 0.1, 0.1));
         break;
     case Options::MouseClose:
         closeWindow();
         break;
     case Options::MouseActivateRaiseAndMove:
     case Options::MouseActivateRaiseAndUnrestrictedMove:
         workspace()->raiseClient(this);
         workspace()->requestFocus(this);
         screens()->setCurrent(globalPos);
         // fallthrough
     case Options::MouseMove:
     case Options::MouseUnrestrictedMove: {
         if (!isMovableAcrossScreens())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerMode(PositionCenter);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(globalPos.x() - x(), globalPos.y() - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize((cmd == Options::MouseActivateRaiseAndUnrestrictedMove
                                   || cmd == Options::MouseUnrestrictedMove));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
     case Options::MouseResize:
     case Options::MouseUnrestrictedResize: {
         if (!isResizable() || isShade())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         const QPoint moveOffset = QPoint(globalPos.x() - x(), globalPos.y() - y());  // map from global
         setMoveOffset(moveOffset);
         int x = moveOffset.x(), y = moveOffset.y();
         bool left = x < width() / 3;
         bool right = x >= 2 * width() / 3;
         bool top = y < height() / 3;
         bool bot = y >= 2 * height() / 3;
         Position mode;
         if (top)
             mode = left ? PositionTopLeft : (right ? PositionTopRight : PositionTop);
         else if (bot)
             mode = left ? PositionBottomLeft : (right ? PositionBottomRight : PositionBottom);
         else
             mode = (x < width() / 2) ? PositionLeft : PositionRight;
         setMoveResizePointerMode(mode);
         setInvertedMoveOffset(rect().bottomRight() - moveOffset);
         setUnrestrictedMoveResize((cmd == Options::MouseUnrestrictedResize));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
+    case Options::MouseShade:
+        toggleShade();
+        cancelShadeHoverTimer();
+        break;
+    case Options::MouseSetShade:
+        setShade(ShadeNormal);
+        cancelShadeHoverTimer();
+        break;
+    case Options::MouseUnsetShade:
+        setShade(ShadeNone);
+        cancelShadeHoverTimer();
+        break;
     case Options::MouseNothing:
     default:
         replay = true;
         break;
     }
     return replay;
 }
 
 void AbstractClient::setTransientFor(AbstractClient *transientFor)
 {
     if (transientFor == this) {
         // cannot be transient for one self
         return;
     }
     if (m_transientFor == transientFor) {
         return;
     }
     m_transientFor = transientFor;
     emit transientChanged();
 }
 
 const AbstractClient *AbstractClient::transientFor() const
 {
     return m_transientFor;
 }
 
 AbstractClient *AbstractClient::transientFor()
 {
     return m_transientFor;
 }
 
 bool AbstractClient::hasTransientPlacementHint() const
 {
     return false;
 }
 
 QRect AbstractClient::transientPlacement(const QRect &bounds) const
 {
     Q_UNUSED(bounds);
     Q_UNREACHABLE();
     return QRect();
 }
 
 bool AbstractClient::hasTransient(const AbstractClient *c, bool indirect) const
 {
     Q_UNUSED(indirect);
     return c->transientFor() == this;
 }
 
 QList< AbstractClient* > AbstractClient::mainClients() const
 {
     if (const AbstractClient *t = transientFor()) {
         return QList<AbstractClient*>{const_cast< AbstractClient* >(t)};
     }
     return QList<AbstractClient*>();
 }
 
 QList<AbstractClient*> AbstractClient::allMainClients() const
 {
     auto result = mainClients();
     foreach (const auto *cl, result) {
         result += cl->allMainClients();
     }
     return result;
 }
 
 void AbstractClient::setModal(bool m)
 {
     // Qt-3.2 can have even modal normal windows :(
     if (m_modal == m)
         return;
     m_modal = m;
     emit modalChanged();
     // Changing modality for a mapped window is weird (?)
     // _NET_WM_STATE_MODAL should possibly rather be _NET_WM_WINDOW_TYPE_MODAL_DIALOG
 }
 
 bool AbstractClient::isModal() const
 {
     return m_modal;
 }
 
 void AbstractClient::addTransient(AbstractClient *cl)
 {
     Q_ASSERT(!m_transients.contains(cl));
     Q_ASSERT(cl != this);
     m_transients.append(cl);
 }
 
 void AbstractClient::removeTransient(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
     if (cl->transientFor() == this) {
         cl->setTransientFor(nullptr);
     }
 }
 
 void AbstractClient::removeTransientFromList(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
 }
 
 bool AbstractClient::isActiveFullScreen() const
 {
     if (!isFullScreen())
         return false;
 
     const auto ac = workspace()->mostRecentlyActivatedClient(); // instead of activeClient() - avoids flicker
     // according to NETWM spec implementation notes suggests
     // "focused windows having state _NET_WM_STATE_FULLSCREEN" to be on the highest layer.
     // we'll also take the screen into account
     return ac && (ac == this || ac->screen() != screen()|| ac->allMainClients().contains(const_cast<AbstractClient*>(this)));
 }
 
 #define BORDER(which) \
     int AbstractClient::border##which() const \
     { \
         return isDecorated() ? decoration()->border##which() : 0; \
     }
 
 BORDER(Bottom)
 BORDER(Left)
 BORDER(Right)
 BORDER(Top)
 #undef BORDER
 
 void AbstractClient::addRepaintDuringGeometryUpdates()
 {
     const QRect deco_rect = visibleRect();
     addLayerRepaint(m_visibleRectBeforeGeometryUpdate);
     addLayerRepaint(deco_rect);   // trigger repaint of window's new location
     m_visibleRectBeforeGeometryUpdate = deco_rect;
 }
 
 QRect AbstractClient::bufferGeometryBeforeUpdateBlocking() const
 {
     return m_bufferGeometryBeforeUpdateBlocking;
 }
 
 QRect AbstractClient::frameGeometryBeforeUpdateBlocking() const
 {
     return m_frameGeometryBeforeUpdateBlocking;
 }
 
 void AbstractClient::updateGeometryBeforeUpdateBlocking()
 {
     m_bufferGeometryBeforeUpdateBlocking = bufferGeometry();
     m_frameGeometryBeforeUpdateBlocking = frameGeometry();
 }
 
 void AbstractClient::doMove(int, int)
 {
 }
 
 void AbstractClient::updateInitialMoveResizeGeometry()
 {
     m_moveResize.initialGeometry = frameGeometry();
     m_moveResize.geometry = m_moveResize.initialGeometry;
     m_moveResize.startScreen = screen();
 }
 
 void AbstractClient::updateCursor()
 {
     Position m = moveResizePointerMode();
     if (!isResizable() || isShade())
         m = PositionCenter;
     CursorShape c = Qt::ArrowCursor;
     switch(m) {
     case PositionTopLeft:
         c = KWin::ExtendedCursor::SizeNorthWest;
         break;
     case PositionBottomRight:
         c = KWin::ExtendedCursor::SizeSouthEast;
         break;
     case PositionBottomLeft:
         c = KWin::ExtendedCursor::SizeSouthWest;
         break;
     case PositionTopRight:
         c = KWin::ExtendedCursor::SizeNorthEast;
         break;
     case PositionTop:
         c = KWin::ExtendedCursor::SizeNorth;
         break;
     case PositionBottom:
         c = KWin::ExtendedCursor::SizeSouth;
         break;
     case PositionLeft:
         c = KWin::ExtendedCursor::SizeWest;
         break;
     case PositionRight:
         c = KWin::ExtendedCursor::SizeEast;
         break;
     default:
         if (isMoveResize())
             c = Qt::SizeAllCursor;
         else
             c = Qt::ArrowCursor;
         break;
     }
     if (c == m_moveResize.cursor)
         return;
     m_moveResize.cursor = c;
     emit moveResizeCursorChanged(c);
 }
 
 void AbstractClient::leaveMoveResize()
 {
     workspace()->setMoveResizeClient(nullptr);
     setMoveResize(false);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(false, Qt::Vertical|Qt::Horizontal);
     if (isElectricBorderMaximizing()) {
         outline()->hide();
         elevate(false);
     }
 }
 
 bool AbstractClient::s_haveResizeEffect = false;
 
 void AbstractClient::updateHaveResizeEffect()
 {
     s_haveResizeEffect = effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::Resize);
 }
 
 bool AbstractClient::doStartMoveResize()
 {
     return true;
 }
 
 void AbstractClient::positionGeometryTip()
 {
 }
 
 void AbstractClient::doPerformMoveResize()
 {
 }
 
 bool AbstractClient::isWaitingForMoveResizeSync() const
 {
     return false;
 }
 
 void AbstractClient::doResizeSync()
 {
 }
 
 void AbstractClient::checkQuickTilingMaximizationZones(int xroot, int yroot)
 {
     QuickTileMode mode = QuickTileFlag::None;
     bool innerBorder = false;
     for (int i=0; i < screens()->count(); ++i) {
 
         if (!screens()->geometry(i).contains(QPoint(xroot, yroot)))
             continue;
 
         auto isInScreen = [i](const QPoint &pt) {
             for (int j = 0; j < screens()->count(); ++j) {
                 if (j == i)
                     continue;
                 if (screens()->geometry(j).contains(pt)) {
                     return true;
                 }
             }
             return false;
         };
 
         QRect area = workspace()->clientArea(MaximizeArea, QPoint(xroot, yroot), desktop());
         if (options->electricBorderTiling()) {
             if (xroot <= area.x() + 20) {
                 mode |= QuickTileFlag::Left;
                 innerBorder = isInScreen(QPoint(area.x() - 1, yroot));
             } else if (xroot >= area.x() + area.width() - 20) {
                 mode |= QuickTileFlag::Right;
                 innerBorder = isInScreen(QPoint(area.right() + 1, yroot));
             }
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Top;
             else if (yroot >= area.y() + area.height() - area.height()  * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Bottom;
         } else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) {
             mode = QuickTileFlag::Maximize;
             innerBorder = isInScreen(QPoint(xroot, area.y() - 1));
         }
         break; // no point in checking other screens to contain this... "point"...
     }
     if (mode != electricBorderMode()) {
         setElectricBorderMode(mode);
         if (innerBorder) {
             if (!m_electricMaximizingDelay) {
                 m_electricMaximizingDelay = new QTimer(this);
                 m_electricMaximizingDelay->setInterval(250);
                 m_electricMaximizingDelay->setSingleShot(true);
                 connect(m_electricMaximizingDelay, &QTimer::timeout, [this]() {
                     if (isMove())
                         setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None));
                 });
             }
             m_electricMaximizingDelay->start();
         } else {
             setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None));
         }
     }
 }
 
 void AbstractClient::keyPressEvent(uint key_code)
 {
     if (!isMove() && !isResize())
         return;
     bool is_control = key_code & Qt::CTRL;
     bool is_alt = key_code & Qt::ALT;
     key_code = key_code & ~Qt::KeyboardModifierMask;
     int delta = is_control ? 1 : is_alt ? 32 : 8;
     QPoint pos = Cursors::self()->mouse()->pos();
     switch(key_code) {
     case Qt::Key_Left:
         pos.rx() -= delta;
         break;
     case Qt::Key_Right:
         pos.rx() += delta;
         break;
     case Qt::Key_Up:
         pos.ry() -= delta;
         break;
     case Qt::Key_Down:
         pos.ry() += delta;
         break;
     case Qt::Key_Space:
     case Qt::Key_Return:
     case Qt::Key_Enter:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(false);
         updateCursor();
         break;
     case Qt::Key_Escape:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(true);
         updateCursor();
         break;
     default:
         return;
     }
     Cursors::self()->mouse()->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::createDecoration(const QRect &oldGeometry)
 {
     KDecoration2::Decoration *decoration = Decoration::DecorationBridge::self()->createDecoration(this);
     if (decoration) {
         QMetaObject::invokeMethod(decoration, "update", Qt::QueuedConnection);
         connect(decoration, &KDecoration2::Decoration::shadowChanged, this, &Toplevel::updateShadow);
         connect(decoration, &KDecoration2::Decoration::bordersChanged, this, [this]() {
             GeometryUpdatesBlocker blocker(this);
             const QRect oldGeometry = frameGeometry();
             if (!isShade()) {
                 checkWorkspacePosition(oldGeometry);
             }
             emit geometryShapeChanged(this, oldGeometry);
         });
     }
     setDecoration(decoration);
     setFrameGeometry(QRect(oldGeometry.topLeft(), clientSizeToFrameSize(clientSize())));
 
     emit geometryShapeChanged(this, oldGeometry);
 }
 
 void AbstractClient::destroyDecoration()
 {
     delete m_decoration.decoration;
     m_decoration.decoration = nullptr;
 }
 
 bool AbstractClient::decorationHasAlpha() const
 {
     if (!isDecorated() || decoration()->isOpaque()) {
         // either no decoration or decoration has alpha disabled
         return false;
     }
     return true;
 }
 
 void AbstractClient::triggerDecorationRepaint()
 {
     if (isDecorated()) {
         decoration()->update();
     }
 }
 
 void AbstractClient::layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const
 {
     if (!isDecorated()) {
         return;
     }
     QRect r = decoration()->rect();
 
     top = QRect(r.x(), r.y(), r.width(), borderTop());
     bottom = QRect(r.x(), r.y() + r.height() - borderBottom(),
                    r.width(), borderBottom());
     left = QRect(r.x(), r.y() + top.height(),
                  borderLeft(), r.height() - top.height() - bottom.height());
     right = QRect(r.x() + r.width() - borderRight(), r.y() + top.height(),
                   borderRight(), r.height() - top.height() - bottom.height());
 }
 
 void AbstractClient::processDecorationMove(const QPoint &localPos, const QPoint &globalPos)
 {
     if (isMoveResizePointerButtonDown()) {
         handleMoveResize(localPos.x(), localPos.y(), globalPos.x(), globalPos.y());
         return;
     }
     // TODO: handle modifiers
     Position newmode = mousePosition();
     if (newmode != moveResizePointerMode()) {
         setMoveResizePointerMode(newmode);
         updateCursor();
     }
 }
 
 bool AbstractClient::processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu)
 {
     Options::MouseCommand com = Options::MouseNothing;
     bool active = isActive();
     if (!wantsInput())    // we cannot be active, use it anyway
         active = true;
 
     // check whether it is a double click
     if (event->button() == Qt::LeftButton && titlebarPositionUnderMouse()) {
         if (m_decoration.doubleClickTimer.isValid()) {
             const qint64 interval = m_decoration.doubleClickTimer.elapsed();
             m_decoration.doubleClickTimer.invalidate();
             if (interval > QGuiApplication::styleHints()->mouseDoubleClickInterval()) {
                 m_decoration.doubleClickTimer.start(); // expired -> new first click and pot. init
             } else {
                 Workspace::self()->performWindowOperation(this, options->operationTitlebarDblClick());
                 dontMoveResize();
                 return false;
             }
         }
          else {
             m_decoration.doubleClickTimer.start(); // new first click and pot. init, could be invalidated by release - see below
         }
     }
 
     if (event->button() == Qt::LeftButton)
         com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();
     else if (event->button() == Qt::MidButton)
         com = active ? options->commandActiveTitlebar2() : options->commandInactiveTitlebar2();
     else if (event->button() == Qt::RightButton)
         com = active ? options->commandActiveTitlebar3() : options->commandInactiveTitlebar3();
     if (event->button() == Qt::LeftButton
             && com != Options::MouseOperationsMenu // actions where it's not possible to get the matching
             && com != Options::MouseMinimize)  // mouse release event
     {
         setMoveResizePointerMode(mousePosition());
         setMoveResizePointerButtonDown(true);
         setMoveOffset(event->pos());
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         startDelayedMoveResize();
         updateCursor();
     }
     // In the new API the decoration may process the menu action to display an inactive tab's menu.
     // If the event is unhandled then the core will create one for the active window in the group.
     if (!ignoreMenu || com != Options::MouseOperationsMenu)
         performMouseCommand(com, event->globalPos());
     return !( // Return events that should be passed to the decoration in the new API
                com == Options::MouseRaise ||
                com == Options::MouseOperationsMenu ||
                com == Options::MouseActivateAndRaise ||
                com == Options::MouseActivate ||
                com == Options::MouseActivateRaiseAndPassClick ||
                com == Options::MouseActivateAndPassClick ||
                com == Options::MouseNothing);
 }
 
 void AbstractClient::processDecorationButtonRelease(QMouseEvent *event)
 {
     if (isDecorated()) {
         if (event->isAccepted() || !titlebarPositionUnderMouse()) {
             invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
         }
     }
 
     if (event->buttons() == Qt::NoButton) {
         setMoveResizePointerButtonDown(false);
         stopDelayedMoveResize();
         if (isMoveResize()) {
             finishMoveResize(false);
             setMoveResizePointerMode(mousePosition());
         }
         updateCursor();
     }
 }
 
 
 void AbstractClient::startDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.start();
 }
 
 void AbstractClient::invalidateDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.invalidate();
 }
 
 bool AbstractClient::providesContextHelp() const
 {
     return false;
 }
 
 void AbstractClient::showContextHelp()
 {
 }
 
 QPointer<Decoration::DecoratedClientImpl> AbstractClient::decoratedClient() const
 {
     return m_decoration.client;
 }
 
 void AbstractClient::setDecoratedClient(QPointer< Decoration::DecoratedClientImpl > client)
 {
     m_decoration.client = client;
 }
 
 void AbstractClient::enterEvent(const QPoint &globalPos)
 {
-    // TODO: shade hover
+    if (options->isShadeHover()) {
+        cancelShadeHoverTimer();
+        startShadeHoverTimer();
+    }
+
     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
+    cancelShadeHoverTimer();
+    startShadeUnhoverTimer();
     // 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()->findClient(i.key());
         if (!client) {
             continue;
         }
         const int distance = QPoint(client->pos() - pos()).manhattanLength();
         if (distance < minDistance) {
             minDistance = distance;
             candidatePanel = client;
             candidateGeom = i.value();
         }
     }
     if (!candidatePanel) {
         return QRect();
     }
     return candidateGeom.translated(candidatePanel->pos());
 }
 
 QRect AbstractClient::inputGeometry() const
 {
     if (isDecorated()) {
         return Toplevel::inputGeometry() + decoration()->resizeOnlyBorders();
     }
     return Toplevel::inputGeometry();
 }
 
 QRect AbstractClient::virtualKeyboardGeometry() const
 {
     return m_virtualKeyboardGeometry;
 }
 
 void AbstractClient::setVirtualKeyboardGeometry(const QRect &geo)
 {
     // No keyboard anymore
     if (geo.isEmpty() && !m_keyboardGeometryRestore.isEmpty()) {
         setFrameGeometry(m_keyboardGeometryRestore);
         m_keyboardGeometryRestore = QRect();
     } else if (geo.isEmpty()) {
         return;
     // The keyboard has just been opened (rather than resized) save client geometry for a restore
     } else if (m_keyboardGeometryRestore.isEmpty()) {
         m_keyboardGeometryRestore = frameGeometry();
     }
 
     m_virtualKeyboardGeometry = geo;
 
     // Don't resize Desktop and fullscreen windows
     if (isFullScreen() || isDesktop()) {
         return;
     }
 
     if (!geo.intersects(m_keyboardGeometryRestore)) {
         return;
     }
 
     const QRect availableArea = workspace()->clientArea(MaximizeArea, this);
     QRect newWindowGeometry = m_keyboardGeometryRestore;
     newWindowGeometry.moveBottom(geo.top());
     newWindowGeometry.setTop(qMax(newWindowGeometry.top(), availableArea.top()));
 
     setFrameGeometry(newWindowGeometry);
 }
 
 bool AbstractClient::dockWantsInput() const
 {
     return false;
 }
 
 void AbstractClient::setDesktopFileName(QByteArray name)
 {
     name = rules()->checkDesktopFile(name).toUtf8();
     if (name == m_desktopFileName) {
         return;
     }
     m_desktopFileName = name;
     updateWindowRules(Rules::DesktopFile);
     emit desktopFileNameChanged();
 }
 
 QString AbstractClient::iconFromDesktopFile() const
 {
     if (m_desktopFileName.isEmpty()) {
         return QString();
     }
     QString desktopFile = QString::fromUtf8(m_desktopFileName);
     if (!desktopFile.endsWith(QLatin1String(".desktop"))) {
         desktopFile.append(QLatin1String(".desktop"));
     }
     KDesktopFile df(desktopFile);
     return df.readIcon();
 }
 
 bool AbstractClient::hasApplicationMenu() const
 {
     return ApplicationMenu::self()->applicationMenuEnabled() && !m_applicationMenuServiceName.isEmpty() && !m_applicationMenuObjectPath.isEmpty();
 }
 
 void AbstractClient::updateApplicationMenuServiceName(const QString &serviceName)
 {
     const bool old_hasApplicationMenu = hasApplicationMenu();
 
     m_applicationMenuServiceName = serviceName;
 
     const bool new_hasApplicationMenu = hasApplicationMenu();
 
     emit applicationMenuChanged();
     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();
 
     emit applicationMenuChanged();
     if (old_hasApplicationMenu != new_hasApplicationMenu) {
         emit hasApplicationMenuChanged(new_hasApplicationMenu);
     }
 }
 
 void AbstractClient::setApplicationMenuActive(bool applicationMenuActive)
 {
     if (m_applicationMenuActive != applicationMenuActive) {
         m_applicationMenuActive = applicationMenuActive;
         emit applicationMenuActiveChanged(applicationMenuActive);
     }
 }
 
 void AbstractClient::showApplicationMenu(int actionId)
 {
     if (isDecorated()) {
         decoration()->showApplicationMenu(actionId);
     } else {
         // we don't know where the application menu button will be, show it in the top left corner instead
         Workspace::self()->showApplicationMenu(QRect(), this, actionId);
     }
 }
 
 bool AbstractClient::unresponsive() const
 {
     return m_unresponsive;
 }
 
 void AbstractClient::setUnresponsive(bool unresponsive)
 {
     if (m_unresponsive != unresponsive) {
         m_unresponsive = unresponsive;
         emit unresponsiveChanged(m_unresponsive);
         emit captionChanged();
     }
 }
 
 QString AbstractClient::shortcutCaptionSuffix() const
 {
     if (shortcut().isEmpty()) {
         return QString();
     }
     return QLatin1String(" {") + shortcut().toString() + QLatin1Char('}');
 }
 
 AbstractClient *AbstractClient::findClientWithSameCaption() const
 {
     auto fetchNameInternalPredicate = [this](const AbstractClient *cl) {
         return (!cl->isSpecialWindow() || cl->isToolbar()) && cl != this && cl->captionNormal() == captionNormal() && cl->captionSuffix() == captionSuffix();
     };
     return workspace()->findAbstractClient(fetchNameInternalPredicate);
 }
 
 QString AbstractClient::caption() const
 {
     QString cap = captionNormal() + captionSuffix();
     if (unresponsive()) {
         cap += QLatin1String(" ");
         cap += i18nc("Application is not responding, appended to window title", "(Not Responding)");
     }
     return cap;
 }
 
 void AbstractClient::removeRule(Rules* rule)
 {
     m_rules.remove(rule);
 }
 
 void AbstractClient::discardTemporaryRules()
 {
     m_rules.discardTemporary();
 }
 
 void AbstractClient::evaluateWindowRules()
 {
     setupWindowRules(true);
     applyWindowRules();
 }
 
 void AbstractClient::setOnActivities(QStringList newActivitiesList)
 {
     Q_UNUSED(newActivitiesList)
 }
 
 void AbstractClient::checkNoBorder()
 {
     setNoBorder(false);
 }
 
 bool AbstractClient::groupTransient() const
 {
     return false;
 }
 
 const Group *AbstractClient::group() const
 {
     return nullptr;
 }
 
 Group *AbstractClient::group()
 {
     return nullptr;
 }
 
 bool AbstractClient::isInternal() const
 {
     return false;
 }
 
 bool AbstractClient::supportsWindowRules() const
 {
     return true;
 }
 
 QMargins AbstractClient::frameMargins() const
 {
     return QMargins(borderLeft(), borderTop(), borderRight(), borderBottom());
 }
 
 QPoint AbstractClient::framePosToClientPos(const QPoint &point) const
 {
     return point + QPoint(borderLeft(), borderTop());
 }
 
 QPoint AbstractClient::clientPosToFramePos(const QPoint &point) const
 {
     return point - QPoint(borderLeft(), borderTop());
 }
 
 QSize AbstractClient::frameSizeToClientSize(const QSize &size) const
 {
     const int width = size.width() - borderLeft() - borderRight();
     const int height = size.height() - borderTop() - borderBottom();
     return QSize(width, height);
 }
 
 QSize AbstractClient::clientSizeToFrameSize(const QSize &size) const
 {
     const int width = size.width() + borderLeft() + borderRight();
     const int height = size.height() + borderTop() + borderBottom();
     return QSize(width, height);
 }
 
 QRect AbstractClient::frameRectToClientRect(const QRect &rect) const
 {
     const QPoint position = framePosToClientPos(rect.topLeft());
     const QSize size = frameSizeToClientSize(rect.size());
     return QRect(position, size);
 }
 
 QRect AbstractClient::clientRectToFrameRect(const QRect &rect) const
 {
     const QPoint position = clientPosToFramePos(rect.topLeft());
     const QSize size = clientSizeToFrameSize(rect.size());
     return QRect(position, size);
 }
 
 void AbstractClient::setElectricBorderMode(QuickTileMode mode)
 {
     if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
         // sanitize the mode, ie. simplify "invalid" combinations
         if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
             mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
         if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
             mode &= ~QuickTileMode(QuickTileFlag::Vertical);
     }
     m_electricMode = mode;
 }
 
 void AbstractClient::setElectricBorderMaximizing(bool maximizing)
 {
     m_electricMaximizing = maximizing;
     if (maximizing)
         outline()->show(electricBorderMaximizeGeometry(Cursors::self()->mouse()->pos(), desktop()), moveResizeGeometry());
     else
         outline()->hide();
     elevate(maximizing);
 }
 
 QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop)
 {
     if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) {
         if (maximizeMode() == MaximizeFull)
             return geometryRestore();
         else
             return workspace()->clientArea(MaximizeArea, pos, desktop);
     }
 
     QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop);
     if (electricBorderMode() & QuickTileFlag::Left)
         ret.setRight(ret.left()+ret.width()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Right)
         ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1);
     if (electricBorderMode() & QuickTileFlag::Top)
         ret.setBottom(ret.top()+ret.height()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Bottom)
         ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1);
 
     return ret;
 }
 
 void AbstractClient::setQuickTileMode(QuickTileMode mode, bool keyboard)
 {
     // Only allow quick tile on a regular window.
     if (!isResizable()) {
         return;
     }
 
     workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
 
     GeometryUpdatesBlocker blocker(this);
 
     if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
         m_quickTileMode = int(QuickTileFlag::None);
         if (maximizeMode() == MaximizeFull) {
             setMaximize(false, false);
         } else {
             QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore
             m_quickTileMode = int(QuickTileFlag::Maximize);
             setMaximize(true, true);
             QRect clientArea = workspace()->clientArea(MaximizeArea, this);
             if (frameGeometry().top() != clientArea.top()) {
                 QRect r(frameGeometry());
                 r.moveTop(clientArea.top());
                 setFrameGeometry(r);
             }
             setGeometryRestore(prev_geom_restore);
         }
         emit quickTileModeChanged();
         return;
     }
 
     // sanitize the mode, ie. simplify "invalid" combinations
     if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
         mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
     if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
         mode &= ~QuickTileMode(QuickTileFlag::Vertical);
 
     setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
 
     // restore from maximized so that it is possible to tile maximized windows with one hit or by dragging
     if (maximizeMode() != MaximizeRestore) {
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused
 
             setMaximize(false, false);
 
             setFrameGeometry(electricBorderMaximizeGeometry(keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos(), desktop()), geom_mode);
             // Store the mode change
             m_quickTileMode = mode;
         } else {
             m_quickTileMode = mode;
             setMaximize(false, false);
         }
 
         emit quickTileModeChanged();
 
         return;
     }
 
     if (mode != QuickTileMode(QuickTileFlag::None)) {
         QPoint whichScreen = keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos();
 
         // If trying to tile to the side that the window is already tiled to move the window to the next
         // screen if it exists, otherwise toggle the mode (set QuickTileFlag::None)
         if (quickTileMode() == mode) {
             const int numScreens = screens()->count();
             const int curScreen = screen();
             int nextScreen = curScreen;
             QVarLengthArray<QRect> screens(numScreens);
             for (int i = 0; i < numScreens; ++i)   // Cache
                 screens[i] = Screens::self()->geometry(i);
             for (int i = 0; i < numScreens; ++i) {
 
                 if (i == curScreen)
                     continue;
 
                 if (screens[i].bottom() <= screens[curScreen].top() || screens[i].top() >= screens[curScreen].bottom())
                     continue; // not in horizontal line
 
                 const int x = screens[i].center().x();
                 if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) {
                     if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x()))
                         continue; // not left of current or more left then found next
                 } else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) {
                     if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x()))
                         continue; // not right of current or more right then found next
                 }
 
                 nextScreen = i;
             }
 
             if (nextScreen == curScreen) {
                 mode = QuickTileFlag::None; // No other screens, toggle tiling
             } else {
                 // Move to other screen
                 setFrameGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft()));
                 whichScreen = screens[nextScreen].center();
 
                 // Swap sides
                 if (mode & QuickTileFlag::Horizontal) {
                     mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical);
                 }
             }
             setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
             // Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile.
             // Store geometry first, so we can go out of this tile later.
             setGeometryRestore(frameGeometry());
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             m_quickTileMode = mode;
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             // Temporary, so the maximize code doesn't get all confused
             m_quickTileMode = int(QuickTileFlag::None);
             setFrameGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode);
         }
 
         // Store the mode change
         m_quickTileMode = mode;
     }
 
     if (mode == QuickTileMode(QuickTileFlag::None)) {
         m_quickTileMode = int(QuickTileFlag::None);
         // Untiling, so just restore geometry, and we're done.
         if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement
             setGeometryRestore(frameGeometry());
         // decorations may turn off some borders when tiled
         const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
         setFrameGeometry(geometryRestore(), geom_mode);
         checkWorkspacePosition(); // Just in case it's a different screen
     }
     emit quickTileModeChanged();
 }
 
 void AbstractClient::sendToScreen(int newScreen)
 {
     newScreen = rules()->checkScreen(newScreen);
     if (isActive()) {
         screens()->setCurrent(newScreen);
         // might impact the layer of a fullscreen window
         foreach (AbstractClient *cc, workspace()->allClientList()) {
             if (cc->isFullScreen() && cc->screen() == newScreen) {
                 cc->updateLayer();
             }
         }
     }
     if (screen() == newScreen)   // Don't use isOnScreen(), that's true even when only partially
         return;
 
     GeometryUpdatesBlocker blocker(this);
 
     // operating on the maximized / quicktiled window would leave the old geom_restore behind,
     // so we clear the state first
     MaximizeMode maxMode = maximizeMode();
     QuickTileMode qtMode = quickTileMode();
     if (maxMode != MaximizeRestore)
         maximize(MaximizeRestore);
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         setQuickTileMode(QuickTileFlag::None, true);
 
     QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this);
     QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop());
 
     // the window can have its center so that the position correction moves the new center onto
     // the old screen, what will tile it where it is. Ie. the screen is not changed
     // this happens esp. with electric border quicktiling
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         keepInArea(oldScreenArea);
 
     QRect oldGeom = frameGeometry();
     QRect newGeom = oldGeom;
     // move the window to have the same relative position to the center of the screen
     // (i.e. one near the middle of the right edge will also end up near the middle of the right edge)
     QPoint center = newGeom.center() - oldScreenArea.center();
     center.setX(center.x() * screenArea.width() / oldScreenArea.width());
     center.setY(center.y() * screenArea.height() / oldScreenArea.height());
     center += screenArea.center();
     newGeom.moveCenter(center);
     setFrameGeometry(newGeom);
 
     // If the window was inside the old screen area, explicitly make sure its inside also the new screen area.
     // Calling checkWorkspacePosition() should ensure that, but when moving to a small screen the window could
     // be big enough to overlap outside of the new screen area, making struts from other screens come into effect,
     // which could alter the resulting geometry.
     if (oldScreenArea.contains(oldGeom)) {
         keepInArea(screenArea);
     }
 
     // align geom_restore - checkWorkspacePosition operates on it
     setGeometryRestore(frameGeometry());
 
     checkWorkspacePosition(oldGeom);
 
     // re-align geom_restore to constrained geometry
     setGeometryRestore(frameGeometry());
 
     // finally reset special states
     // NOTICE that MaximizeRestore/QuickTileFlag::None checks are required.
     // eg. setting QuickTileFlag::None would break maximization
     if (maxMode != MaximizeRestore)
         maximize(maxMode);
     if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode())
         setQuickTileMode(qtMode, true);
 
     auto tso = workspace()->ensureStackingOrder(transients());
     for (auto it = tso.constBegin(), end = tso.constEnd(); it != end; ++it)
         (*it)->sendToScreen(newScreen);
 }
 
 void AbstractClient::checkWorkspacePosition(QRect oldGeometry, int oldDesktop, QRect oldClientGeometry)
 {
     enum { Left = 0, Top, Right, Bottom };
     const int border[4] = { borderLeft(), borderTop(), borderRight(), borderBottom() };
     if( !oldGeometry.isValid())
         oldGeometry = frameGeometry();
     if( oldDesktop == -2 )
         oldDesktop = desktop();
     if (!oldClientGeometry.isValid())
         oldClientGeometry = oldGeometry.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     if (isDesktop())
         return;
     if (isFullScreen()) {
         QRect area = workspace()->clientArea(FullScreenArea, this);
         if (frameGeometry() != area)
             setFrameGeometry(area);
         return;
     }
     if (isDock())
         return;
 
     if (maximizeMode() != MaximizeRestore) {
         // TODO update geom_restore?
         changeMaximize(false, false, true);   // adjust size
         const QRect screenArea = workspace()->clientArea(ScreenArea, this);
         QRect geom = frameGeometry();
         checkOffscreenPosition(&geom, screenArea);
         setFrameGeometry(geom);
         return;
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         setFrameGeometry(electricBorderMaximizeGeometry(frameGeometry().center(), desktop()));
         return;
     }
 
     // this can be true only if this window was mapped before KWin
     // was started - in such case, don't adjust position to workarea,
     // because the window already had its position, and if a window
     // with a strut altering the workarea would be managed in initialization
     // after this one, this window would be moved
     if (!workspace() || workspace()->initializing())
         return;
 
     // If the window was touching an edge before but not now move it so it is again.
     // Old and new maximums have different starting values so windows on the screen
     // edge will move when a new strut is placed on the edge.
     QRect oldScreenArea;
     if( workspace()->inUpdateClientArea()) {
         // we need to find the screen area as it was before the change
         oldScreenArea = QRect( 0, 0, workspace()->oldDisplayWidth(), workspace()->oldDisplayHeight());
         int distance = INT_MAX;
         foreach(const QRect &r, workspace()->previousScreenSizes()) {
             int d = r.contains( oldGeometry.center()) ? 0 : ( r.center() - oldGeometry.center()).manhattanLength();
             if( d < distance ) {
                 distance = d;
                 oldScreenArea = r;
             }
         }
     } else {
         oldScreenArea = workspace()->clientArea(ScreenArea, oldGeometry.center(), oldDesktop);
     }
     const QRect oldGeomTall = QRect(oldGeometry.x(), oldScreenArea.y(), oldGeometry.width(), oldScreenArea.height());   // Full screen height
     const QRect oldGeomWide = QRect(oldScreenArea.x(), oldGeometry.y(), oldScreenArea.width(), oldGeometry.height());   // Full screen width
     int oldTopMax = oldScreenArea.y();
     int oldRightMax = oldScreenArea.x() + oldScreenArea.width();
     int oldBottomMax = oldScreenArea.y() + oldScreenArea.height();
     int oldLeftMax = oldScreenArea.x();
     const QRect screenArea = workspace()->clientArea(ScreenArea, geometryRestore().center(), desktop());
     int topMax = screenArea.y();
     int rightMax = screenArea.x() + screenArea.width();
     int bottomMax = screenArea.y() + screenArea.height();
     int leftMax = screenArea.x();
     QRect newGeom = geometryRestore(); // geometry();
     QRect newClientGeom = newGeom.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     const QRect newGeomTall = QRect(newGeom.x(), screenArea.y(), newGeom.width(), screenArea.height());   // Full screen height
     const QRect newGeomWide = QRect(screenArea.x(), newGeom.y(), screenArea.width(), newGeom.height());   // Full screen width
     // Get the max strut point for each side where the window is (E.g. Highest point for
     // the bottom struts bounded by the window's left and right sides).
 
     // These 4 compute old bounds ...
     auto moveAreaFunc = workspace()->inUpdateClientArea() ?
                                 &Workspace::previousRestrictedMoveArea : //... the restricted areas changed
                                 &Workspace::restrictedMoveArea; //... when e.g. active desktop or screen changes
 
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaTop)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldTopMax = qMax(oldTopMax, rect.y() + rect.height());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaRight)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldRightMax = qMin(oldRightMax, rect.x());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaBottom)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldBottomMax = qMin(oldBottomMax, rect.y());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaLeft)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldLeftMax = qMax(oldLeftMax, rect.x() + rect.width());
     }
 
     // These 4 compute new bounds
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaTop)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             topMax = qMax(topMax, rect.y() + rect.height());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaRight)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             rightMax = qMin(rightMax, rect.x());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaBottom)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             bottomMax = qMin(bottomMax, rect.y());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaLeft)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             leftMax = qMax(leftMax, rect.x() + rect.width());
     }
 
 
     // Check if the sides were inside or touching but are no longer
     bool keep[4] = {false, false, false, false};
     bool save[4] = {false, false, false, false};
     int padding[4] = {0, 0, 0, 0};
     if (oldGeometry.x() >= oldLeftMax)
         save[Left] = newGeom.x() < leftMax;
     if (oldGeometry.x() == oldLeftMax)
         keep[Left] = newGeom.x() != leftMax;
     else if (oldClientGeometry.x() == oldLeftMax && newClientGeom.x() != leftMax) {
         padding[0] = border[Left];
         keep[Left] = true;
     }
     if (oldGeometry.y() >= oldTopMax)
         save[Top] = newGeom.y() < topMax;
     if (oldGeometry.y() == oldTopMax)
         keep[Top] = newGeom.y() != topMax;
     else if (oldClientGeometry.y() == oldTopMax && newClientGeom.y() != topMax) {
         padding[1] = border[Left];
         keep[Top] = true;
     }
     if (oldGeometry.right() <= oldRightMax - 1)
         save[Right] = newGeom.right() > rightMax - 1;
     if (oldGeometry.right() == oldRightMax - 1)
         keep[Right] = newGeom.right() != rightMax - 1;
     else if (oldClientGeometry.right() == oldRightMax - 1 && newClientGeom.right() != rightMax - 1) {
         padding[2] = border[Right];
         keep[Right] = true;
     }
     if (oldGeometry.bottom() <= oldBottomMax - 1)
         save[Bottom] = newGeom.bottom() > bottomMax - 1;
     if (oldGeometry.bottom() == oldBottomMax - 1)
         keep[Bottom] = newGeom.bottom() != bottomMax - 1;
     else if (oldClientGeometry.bottom() == oldBottomMax - 1 && newClientGeom.bottom() != bottomMax - 1) {
         padding[3] = border[Bottom];
         keep[Bottom] = true;
     }
 
     // if randomly touches opposing edges, do not favor either
     if (keep[Left] && keep[Right]) {
         keep[Left] = keep[Right] = false;
         padding[0] = padding[2] = 0;
     }
     if (keep[Top] && keep[Bottom]) {
         keep[Top] = keep[Bottom] = false;
         padding[1] = padding[3] = 0;
     }
 
     if (save[Left] || keep[Left])
         newGeom.moveLeft(qMax(leftMax, screenArea.x()) - padding[0]);
     if (padding[0] && screens()->intersecting(newGeom) > 1)
         newGeom.moveLeft(newGeom.left() + padding[0]);
     if (save[Top] || keep[Top])
         newGeom.moveTop(qMax(topMax, screenArea.y()) - padding[1]);
     if (padding[1] && screens()->intersecting(newGeom) > 1)
         newGeom.moveTop(newGeom.top() + padding[1]);
     if (save[Right] || keep[Right])
         newGeom.moveRight(qMin(rightMax - 1, screenArea.right()) + padding[2]);
     if (padding[2] && screens()->intersecting(newGeom) > 1)
         newGeom.moveRight(newGeom.right() - padding[2]);
     if (oldGeometry.x() >= oldLeftMax && newGeom.x() < leftMax)
         newGeom.setLeft(qMax(leftMax, screenArea.x()));
     else if (oldClientGeometry.x() >= oldLeftMax && newGeom.x() + border[Left] < leftMax) {
         newGeom.setLeft(qMax(leftMax, screenArea.x()) - border[Left]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setLeft(newGeom.left() + border[Left]);
     }
     if (save[Bottom] || keep[Bottom])
         newGeom.moveBottom(qMin(bottomMax - 1, screenArea.bottom()) + padding[3]);
     if (padding[3] && screens()->intersecting(newGeom) > 1)
         newGeom.moveBottom(newGeom.bottom() - padding[3]);
     if (oldGeometry.y() >= oldTopMax && newGeom.y() < topMax)
         newGeom.setTop(qMax(topMax, screenArea.y()));
     else if (oldClientGeometry.y() >= oldTopMax && newGeom.y() + border[Top] < topMax) {
         newGeom.setTop(qMax(topMax, screenArea.y()) - border[Top]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setTop(newGeom.top() + border[Top]);
     }
 
     checkOffscreenPosition(&newGeom, screenArea);
     // Obey size hints. TODO: We really should make sure it stays in the right place
     if (!isShade())
         newGeom.setSize(constrainFrameSize(newGeom.size()));
 
     if (newGeom != frameGeometry())
         setFrameGeometry(newGeom);
 }
 
 void AbstractClient::checkOffscreenPosition(QRect* geom, const QRect& screenArea)
 {
     if (geom->left() > screenArea.right()) {
         geom->moveLeft(screenArea.right() - screenArea.width()/4);
     } else if (geom->right() < screenArea.left()) {
         geom->moveRight(screenArea.left() + screenArea.width()/4);
     }
     if (geom->top() > screenArea.bottom()) {
         geom->moveTop(screenArea.bottom() - screenArea.height()/4);
     } else if (geom->bottom() < screenArea.top()) {
         geom->moveBottom(screenArea.top() + screenArea.width()/4);
     }
 }
 
 /**
  * Returns the appropriate frame size for the current client size.
  *
  * This is equivalent to clientSizeToFrameSize(constrainClientSize(clientSize())).
  */
 QSize AbstractClient::adjustedSize() const
 {
     return clientSizeToFrameSize(constrainClientSize(clientSize()));
 }
 
 /**
  * Constrains the client size @p size according to a set of the window's size hints.
  *
  * Default implementation applies only minimum and maximum size constraints.
  */
 QSize AbstractClient::constrainClientSize(const QSize &size, SizeMode mode) const
 {
     Q_UNUSED(mode)
 
     int width = size.width();
     int height = size.height();
 
     // When user is resizing the window, the move resize geometry may have negative width or
     // height. In which case, we need to set negative dimensions to reasonable values.
     if (width < 1) {
         width = 1;
     }
     if (height < 1) {
         height = 1;
     }
 
     const QSize minimumSize = minSize();
     const QSize maximumSize = maxSize();
 
     width = qBound(minimumSize.width(), width, maximumSize.width());
     height = qBound(minimumSize.height(), height, maximumSize.height());
 
     return QSize(width, height);
 }
 
 /**
  * Constrains the frame size @p size according to a set of the window's size hints.
  */
 QSize AbstractClient::constrainFrameSize(const QSize &size, SizeMode mode) const
 {
     const QSize unconstrainedClientSize = frameSizeToClientSize(size);
     const QSize constrainedClientSize = constrainClientSize(unconstrainedClientSize, mode);
     return clientSizeToFrameSize(constrainedClientSize);
 }
 
 /**
  * Returns @c true if the AbstractClient can be shown in full screen mode; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreenable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient is currently being shown in full screen mode; otherwise @c false.
  *
  * A client in full screen mode occupies the entire screen with no window frame around it.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreen() const
 {
     return false;
 }
 
 /**
  * Returns whether requests initiated by the user to enter or leave full screen mode are honored.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::userCanSetFullScreen() const
 {
     return false;
 }
 
 /**
  * Asks the AbstractClient to enter or leave full screen mode.
  *
  * Default implementation does nothing.
  *
  * @param set @c true if the AbstractClient has to be shown in full screen mode, otherwise @c false
  * @param user @c true if the request is initiated by the user, otherwise @c false
  */
 void AbstractClient::setFullScreen(bool set, bool user)
 {
     Q_UNUSED(set)
     Q_UNUSED(user)
 }
 
 /**
  * Returns @c true if the AbstractClient can be minimized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMinimizable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient can be maximized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMaximizable() const
 {
     return false;
 }
 
 /**
  * Returns the currently applied maximize mode.
  *
  * Default implementation returns MaximizeRestore.
  */
 MaximizeMode AbstractClient::maximizeMode() const
 {
     return MaximizeRestore;
 }
 
 /**
  * Returns the last requested maximize mode.
  *
  * On X11, this method always matches maximizeMode(). On Wayland, it is asynchronous.
  *
  * Default implementation matches maximizeMode().
  */
 MaximizeMode AbstractClient::requestedMaximizeMode() const
 {
     return maximizeMode();
 }
 
 /**
  * Returns the geometry of the AbstractClient before it was maximized or quick tiled.
  */
 QRect AbstractClient::geometryRestore() const
 {
     return m_maximizeGeometryRestore;
 }
 
 /**
  * Sets the geometry of the AbstractClient before it was maximized or quick tiled to @p rect.
  */
 void AbstractClient::setGeometryRestore(const QRect &rect)
 {
     m_maximizeGeometryRestore = rect;
 }
 
 /**
  * Toggles the maximized state along specified dimensions @p horizontal and @p vertical.
  *
  * If @p adjust is @c true, only frame geometry will be updated to match requestedMaximizeMode().
  *
  * Default implementation does nothing.
  */
 void AbstractClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     Q_UNUSED(horizontal)
     Q_UNUSED(vertical)
     Q_UNUSED(adjust)
 }
 
 }
diff --git a/abstract_client.h b/abstract_client.h
index cf1ad4af0..2b5c3b337 100644
--- a/abstract_client.h
+++ b/abstract_client.h
@@ -1,1349 +1,1361 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_CLIENT_H
 #define KWIN_ABSTRACT_CLIENT_H
 
 #include "toplevel.h"
 #include "options.h"
 #include "rules.h"
 #include "cursor.h"
 
 #include <memory>
 
 #include <QElapsedTimer>
 #include <QPointer>
 
 namespace KWaylandServer
 {
 class PlasmaWindowInterface;
 }
 
 namespace KDecoration2
 {
 class Decoration;
 }
 
 namespace KWin
 {
 class Group;
 
 namespace TabBox
 {
 class TabBoxClientImpl;
 }
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class DecorationPalette;
 }
 
 class KWIN_EXPORT AbstractClient : public Toplevel
 {
     Q_OBJECT
 
     /**
      * Whether this Client is fullScreen. A Client might either be fullScreen due to the _NET_WM property
      * or through a legacy support hack. The fullScreen state can only be changed if the Client does not
      * use the legacy hack. To be sure whether the state changed, connect to the notify signal.
      */
     Q_PROPERTY(bool fullScreen READ isFullScreen WRITE setFullScreen NOTIFY fullScreenChanged)
 
     /**
      * Whether the Client can be set to fullScreen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool fullScreenable READ isFullScreenable)
 
     /**
      * Whether this Client is active or not. Use Workspace::activateClient() to activate a Client.
      * @see Workspace::activateClient
      */
     Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)
 
     /**
      * The desktop this Client is on. If the Client is on all desktops the property has value -1.
      * This is a legacy property, use x11DesktopIds instead
      */
     Q_PROPERTY(int desktop READ desktop WRITE setDesktop NOTIFY desktopChanged)
 
     /**
      * Whether the Client is on all desktops. That is desktop is -1.
      */
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops WRITE setOnAllDesktops NOTIFY desktopChanged)
 
     /**
      * The x11 ids for all desktops this client is in. On X11 this list will always have a length of 1
      */
     Q_PROPERTY(QVector<uint> x11DesktopIds READ x11DesktopIds NOTIFY x11DesktopIdsChanged)
 
     /**
      * Indicates that the window should not be included on a taskbar.
      */
     Q_PROPERTY(bool skipTaskbar READ skipTaskbar WRITE setSkipTaskbar NOTIFY skipTaskbarChanged)
 
     /**
      * Indicates that the window should not be included on a Pager.
      */
     Q_PROPERTY(bool skipPager READ skipPager WRITE setSkipPager NOTIFY skipPagerChanged)
 
     /**
      * Whether the Client should be excluded from window switching effects.
      */
     Q_PROPERTY(bool skipSwitcher READ skipSwitcher WRITE setSkipSwitcher NOTIFY skipSwitcherChanged)
 
     /**
      * Whether the window can be closed by the user. The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool closeable READ isCloseable)
 
     Q_PROPERTY(QIcon icon READ icon NOTIFY iconChanged)
 
     /**
      * Whether the Client is set to be kept above other windows.
      */
     Q_PROPERTY(bool keepAbove READ keepAbove WRITE setKeepAbove NOTIFY keepAboveChanged)
 
     /**
      * Whether the Client is set to be kept below other windows.
      */
     Q_PROPERTY(bool keepBelow READ keepBelow WRITE setKeepBelow NOTIFY keepBelowChanged)
 
     /**
      * Whether the Client can be shaded. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool shadeable READ isShadeable)
 
     /**
      * Whether the Client is shaded.
      */
     Q_PROPERTY(bool shade READ isShade WRITE setShade NOTIFY shadeChanged)
 
     /**
      * Whether the Client can be minimized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool minimizable READ isMinimizable)
 
     /**
      * Whether the Client is minimized.
      */
     Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized NOTIFY minimizedChanged)
 
     /**
      * The optional geometry representing the minimized Client in e.g a taskbar.
      * See _NET_WM_ICON_GEOMETRY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(QRect iconGeometry READ iconGeometry)
 
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool specialWindow READ isSpecialWindow)
 
     /**
      * Whether window state _NET_WM_STATE_DEMANDS_ATTENTION is set. This state indicates that some
      * action in or with the window happened. For example, it may be set by the Window Manager if
      * the window requested activation but the Window Manager refused it, or the application may set
      * it if it finished some work. This state may be set by both the Client and the Window Manager.
      * It should be unset by the Window Manager when it decides the window got the required attention
      * (usually, that it got activated).
      */
     Q_PROPERTY(bool demandsAttention READ isDemandingAttention WRITE demandAttention NOTIFY demandsAttentionChanged)
 
     /**
      * The Caption of the Client. Read from WM_NAME property together with a suffix for hostname and shortcut.
      * To read only the caption as provided by WM_NAME, use the getter with an additional @c false value.
      */
     Q_PROPERTY(QString caption READ caption NOTIFY captionChanged)
 
     /**
      * Minimum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize minSize READ minSize)
 
     /**
      * Maximum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize maxSize READ maxSize)
 
     /**
      * Whether the Client can accept keyboard focus.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool wantsInput READ wantsInput)
 
     /**
      * Whether the Client is a transient Window to another Window.
      * @see transientFor
      */
     Q_PROPERTY(bool transient READ isTransient NOTIFY transientChanged)
 
     /**
      * The Client to which this Client is a transient if any.
      */
     Q_PROPERTY(KWin::AbstractClient *transientFor READ transientFor NOTIFY transientChanged)
 
     /**
      * Whether the Client represents a modal window.
      */
     Q_PROPERTY(bool modal READ isModal NOTIFY modalChanged)
 
     /**
      * The geometry of this Client. Be aware that depending on resize mode the frameGeometryChanged
      * signal might be emitted at each resize step or only at the end of the resize operation.
      */
     Q_PROPERTY(QRect geometry READ frameGeometry WRITE setFrameGeometry)
 
     /**
      * Whether the Client is currently being moved by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool move READ isMove NOTIFY moveResizedChanged)
 
     /**
      * Whether the Client is currently being resized by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool resize READ isResize NOTIFY moveResizedChanged)
 
     /**
      * Whether the decoration is currently using an alpha channel.
      */
     Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
 
     /**
      * Whether the window has a decoration or not.
      * This property is not allowed to be set by applications themselves.
      * The decision whether a window has a border or not belongs to the window manager.
      * If this property gets abused by application developers, it will be removed again.
      */
     Q_PROPERTY(bool noBorder READ noBorder WRITE setNoBorder)
 
     /**
      * Whether the Client provides context help. Mostly needed by decorations to decide whether to
      * show the help button or not.
      */
     Q_PROPERTY(bool providesContextHelp READ providesContextHelp CONSTANT)
 
     /**
      * Whether the Client can be maximized both horizontally and vertically.
      * The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool maximizable READ isMaximizable)
 
     /**
      * Whether the Client is moveable. Even if it is not moveable, it might be possible to move
      * it to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveableAcrossScreens
      */
     Q_PROPERTY(bool moveable READ isMovable)
 
     /**
      * Whether the Client can be moved to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveable
      */
     Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
 
     /**
      * Whether the Client can be resized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool resizeable READ isResizable)
 
     /**
      * The desktop file name of the application this AbstractClient belongs to.
      *
      * This is either the base name without full path and without file extension of the
      * desktop file for the window's application (e.g. "org.kde.foo").
      *
      * The application's desktop file name can also be the full path to the desktop file
      * (e.g. "/opt/kde/share/org.kde.foo.desktop") in case it's not in a standard location.
      */
     Q_PROPERTY(QByteArray desktopFileName READ desktopFileName NOTIFY desktopFileNameChanged)
 
     /**
      * Whether an application menu is available for this Client
      */
     Q_PROPERTY(bool hasApplicationMenu READ hasApplicationMenu NOTIFY hasApplicationMenuChanged)
 
     /**
      * Whether the application menu for this Client is currently opened
      */
     Q_PROPERTY(bool applicationMenuActive READ applicationMenuActive NOTIFY applicationMenuActiveChanged)
 
     /**
      * Whether this client is unresponsive.
      *
      * When an application failed to react on a ping request in time, it is
      * considered unresponsive. This usually indicates that the application froze or crashed.
      */
     Q_PROPERTY(bool unresponsive READ unresponsive NOTIFY unresponsiveChanged)
 
     /**
      * The color scheme set on this client
      * Absolute file path, or name of palette in the user's config directory following KColorSchemes format.
      * An empty string indicates the default palette from kdeglobals is used.
      * @note this indicates the colour scheme requested, which might differ from the theme applied if the colorScheme cannot be found
      */
     Q_PROPERTY(QString colorScheme READ colorScheme NOTIFY colorSchemeChanged)
 
 public:
     ~AbstractClient() override;
 
     QWeakPointer<TabBox::TabBoxClientImpl> tabBoxClient() const {
         return m_tabBoxClient.toWeakRef();
     }
     bool isFirstInTabBox() const {
         return m_firstInTabBox;
     }
     bool skipSwitcher() const {
         return m_skipSwitcher;
     }
     void setSkipSwitcher(bool set);
 
     bool skipTaskbar() const {
         return m_skipTaskbar;
     }
     void setSkipTaskbar(bool set);
     void setOriginalSkipTaskbar(bool set);
     bool originalSkipTaskbar() const {
         return m_originalSkipTaskbar;
     }
 
     bool skipPager() const {
         return m_skipPager;
     }
     void setSkipPager(bool set);
 
     const QIcon &icon() const {
         return m_icon;
     }
 
     bool isActive() const {
         return m_active;
     }
     /**
      * Sets the client's active state to \a act.
      *
      * This function does only change the visual appearance of the client,
      * it does not change the focus setting. Use
      * Workspace::activateClient() or Workspace::requestFocus() instead.
      *
      * If a client receives or looses the focus, it calls setActive() on
      * its own.
      */
     void setActive(bool);
 
     bool keepAbove() const {
         return m_keepAbove;
     }
     void setKeepAbove(bool);
     bool keepBelow() const {
         return m_keepBelow;
     }
     void setKeepBelow(bool);
 
     void demandAttention(bool set = true);
     bool isDemandingAttention() const {
         return m_demandsAttention;
     }
 
     void cancelAutoRaise();
 
     bool wantsTabFocus() const;
 
     QMargins frameMargins() const override;
     QPoint clientPos() const override {
         return QPoint(borderLeft(), borderTop());
     }
 
     virtual void updateMouseGrab();
     /**
      * @returns The caption consisting of captionNormal and captionSuffix
      * @see captionNormal
      * @see captionSuffix
      */
     QString caption() const;
     /**
      * @returns The caption as set by the AbstractClient without any suffix.
      * @see caption
      * @see captionSuffix
      */
     virtual QString captionNormal() const = 0;
     /**
      * @returns The suffix added to the caption (e.g. shortcut, machine name, etc.)
      * @see caption
      * @see captionNormal
      */
     virtual QString captionSuffix() const = 0;
     virtual bool isCloseable() const = 0;
     // TODO: remove boolean trap
     virtual bool isShown(bool shaded_is_shown) const = 0;
     virtual bool isHiddenInternal() const = 0;
     // TODO: remove boolean trap
     virtual void hideClient(bool hide) = 0;
     virtual bool isFullScreenable() const;
     virtual bool isFullScreen() const;
     // TODO: remove boolean trap
     virtual AbstractClient *findModal(bool allow_itself = false) = 0;
     virtual bool isTransient() const;
     /**
      * @returns Whether there is a hint available to place the AbstractClient on it's parent, default @c false.
      * @see transientPlacementHint
      */
     virtual bool hasTransientPlacementHint() const;
     /**
      * Only valid id hasTransientPlacementHint is true
      * @returns The position the transient wishes to position itself
      */
     virtual QRect transientPlacement(const QRect &bounds) const;
     const AbstractClient* transientFor() const;
     AbstractClient* transientFor();
     /**
      * @returns @c true if c is the transient_for window for this client,
      *  or recursively the transient_for window
      * @todo: remove boolean trap
      */
     virtual bool hasTransient(const AbstractClient* c, bool indirect) const;
     const QList<AbstractClient*>& transients() const; // Is not indirect
     virtual void addTransient(AbstractClient *client);
     virtual void removeTransient(AbstractClient* cl);
     virtual QList<AbstractClient*> mainClients() const; // Call once before loop , is not indirect
     QList<AbstractClient*> allMainClients() const; // Call once before loop , is indirect
     /**
      * Returns true for "special" windows and false for windows which are "normal"
      * (normal=window which has a border, can be moved by the user, can be closed, etc.)
      * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
      * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
      */
     bool isSpecialWindow() const;
     void sendToScreen(int screen);
     const QKeySequence &shortcut() const {
         return _shortcut;
     }
     void setShortcut(const QString &cut);
-    virtual bool performMouseCommand(Options::MouseCommand, const QPoint &globalPos);
+    bool performMouseCommand(Options::MouseCommand, const QPoint &globalPos);
     void setOnAllDesktops(bool set);
     void setDesktop(int);
     void enterDesktop(VirtualDesktop *desktop);
     void leaveDesktop(VirtualDesktop *desktop);
 
     /**
      * Set the window as being on the attached list of desktops
      * On X11 it will be set to the last entry
      */
     void setDesktops(QVector<VirtualDesktop *> desktops);
 
     int desktop() const override {
         return m_desktops.isEmpty() ? (int)NET::OnAllDesktops : m_desktops.last()->x11DesktopNumber();
     }
     QVector<VirtualDesktop *> desktops() const override {
         return m_desktops;
     }
     QVector<uint> x11DesktopIds() const;
 
     void setMinimized(bool set);
     /**
      * Minimizes this client plus its transients
      */
     void minimize(bool avoid_animation = false);
     void unminimize(bool avoid_animation = false);
     bool isMinimized() const {
         return m_minimized;
     }
     virtual void setFullScreen(bool set, bool user = true);
 
     virtual void setClientShown(bool shown);
 
     QRect geometryRestore() const;
     virtual MaximizeMode maximizeMode() const;
     virtual MaximizeMode requestedMaximizeMode() const;
     void maximize(MaximizeMode);
     /**
      * Sets the maximization according to @p vertically and @p horizontally.
      */
     Q_INVOKABLE void setMaximize(bool vertically, bool horizontally);
     virtual bool noBorder() const = 0;
     virtual void setNoBorder(bool set) = 0;
     virtual void blockActivityUpdates(bool b = true) = 0;
     QPalette palette() const;
     const Decoration::DecorationPalette *decorationPalette() const;
     /**
      * Returns whether the window is resizable or has a fixed size.
      */
     virtual bool isResizable() const = 0;
     /**
      * Returns whether the window is moveable or has a fixed position.
      */
     virtual bool isMovable() const = 0;
     /**
      * Returns whether the window can be moved to another screen.
      */
     virtual bool isMovableAcrossScreens() const = 0;
     /**
      * @c true only for @c ShadeNormal
      */
     bool isShade() const {
         return shadeMode() == ShadeNormal;
     }
-    /**
-     * Default implementation returns @c ShadeNone
-     */
-    virtual ShadeMode shadeMode() const; // Prefer isShade()
+    ShadeMode shadeMode() const; // Prefer isShade()
     void setShade(bool set);
-    /**
-     * Default implementation does nothing
-     */
-    virtual void setShade(ShadeMode mode);
+    void setShade(ShadeMode mode);
+    void toggleShade();
+    void cancelShadeHoverTimer();
     /**
      * Whether the Client can be shaded. Default implementation returns @c false.
      */
     virtual bool isShadeable() const;
     virtual bool isMaximizable() const;
     virtual bool isMinimizable() const;
     virtual QRect iconGeometry() const;
     virtual bool userCanSetFullScreen() const;
     virtual bool userCanSetNoBorder() const = 0;
     virtual void checkNoBorder();
     virtual void setOnActivities(QStringList newActivitiesList);
     virtual void setOnAllActivities(bool set) = 0;
     const WindowRules* rules() const {
         return &m_rules;
     }
     void removeRule(Rules* r);
     void setupWindowRules(bool ignore_temporary);
     void evaluateWindowRules();
     virtual void applyWindowRules();
     virtual void takeFocus() = 0;
     virtual bool wantsInput() const = 0;
     /**
      * Whether a dock window wants input.
      *
      * By default KWin doesn't pass focus to a dock window unless a force activate
      * request is provided.
      *
      * This method allows to have dock windows take focus also through flags set on
      * the window.
      *
      * The default implementation returns @c false.
      */
     virtual bool dockWantsInput() const;
     void checkWorkspacePosition(QRect oldGeometry = QRect(), int oldDesktop = -2,  QRect oldClientGeometry = QRect());
     virtual xcb_timestamp_t userTime() const;
     virtual void updateWindowRules(Rules::Types selection);
 
     void growHorizontal();
     void shrinkHorizontal();
     void growVertical();
     void shrinkVertical();
     void updateMoveResize(const QPointF &currentGlobalCursor);
     /**
      * Ends move resize when all pointer buttons are up again.
      */
     void endMoveResize();
     void keyPressEvent(uint key_code);
 
     void enterEvent(const QPoint &globalPos);
     void leaveEvent();
 
     /**
      * These values represent positions inside an area
      */
     enum Position {
         // without prefix, they'd conflict with Qt::TopLeftCorner etc. :(
         PositionCenter         = 0x00,
         PositionLeft           = 0x01,
         PositionRight          = 0x02,
         PositionTop            = 0x04,
         PositionBottom         = 0x08,
         PositionTopLeft        = PositionLeft | PositionTop,
         PositionTopRight       = PositionRight | PositionTop,
         PositionBottomLeft     = PositionLeft | PositionBottom,
         PositionBottomRight    = PositionRight | PositionBottom
     };
     Position titlebarPosition() const;
     bool titlebarPositionUnderMouse() const;
 
     // a helper for the workspace window packing. tests for screen validity and updates since in maximization case as with normal moving
     void packTo(int left, int top);
 
     /**
      * Sets the quick tile mode ("snap") of this window.
      * This will also handle preserving and restoring of window geometry as necessary.
      * @param mode The tile mode (left/right) to give this window.
      * @param keyboard Defines whether to take keyboard cursor into account.
      */
     void setQuickTileMode(QuickTileMode mode, bool keyboard = false);
     QuickTileMode quickTileMode() const {
         return QuickTileMode(m_quickTileMode);
     }
     Layer layer() const override;
     void updateLayer();
 
     void placeIn(const QRect &area);
 
     enum ForceGeometry_t { NormalGeometrySet, ForceGeometrySet };
     virtual void move(int x, int y, ForceGeometry_t force = NormalGeometrySet);
     void move(const QPoint &p, ForceGeometry_t force = NormalGeometrySet);
     virtual void resizeWithChecks(const QSize& s, ForceGeometry_t force = NormalGeometrySet) = 0;
     void keepInArea(QRect area, bool partial = false);
     virtual QSize minSize() const;
     virtual QSize maxSize() const;
     virtual void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet) = 0;
 
     /**
      * How to resize the window in order to obey constraints (mainly aspect ratios).
      */
     enum SizeMode {
         SizeModeAny,
         SizeModeFixedW, ///< Try not to affect width
         SizeModeFixedH, ///< Try not to affect height
         SizeModeMax ///< Try not to make it larger in either direction
     };
 
     virtual QSize constrainClientSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize constrainFrameSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize adjustedSize() const;
 
     /**
      * Calculates the matching client position for the given frame position @p point.
      */
     virtual QPoint framePosToClientPos(const QPoint &point) const;
     /**
      * Calculates the matching frame position for the given client position @p point.
      */
     virtual QPoint clientPosToFramePos(const QPoint &point) const;
     /**
      * Calculates the matching client size for the given frame size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the frame size with frame margins being excluded.
      */
     virtual QSize frameSizeToClientSize(const QSize &size) const;
     /**
      * Calculates the matching frame size for the given client size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the client size with frame margins being included.
      */
     virtual QSize clientSizeToFrameSize(const QSize &size) const;
     /**
      * Calculates the matching client rect for the given frame rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect frameRectToClientRect(const QRect &rect) const;
     /**
      * Calculates the matching frame rect for the given client rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect clientRectToFrameRect(const QRect &rect) const;
 
     /**
      * Returns @c true if the Client is being interactively moved; otherwise @c false.
      */
     bool isMove() const {
         return isMoveResize() && moveResizePointerMode() == PositionCenter;
     }
     /**
      * Returns @c true if the Client is being interactively resized; otherwise @c false.
      */
     bool isResize() const {
         return isMoveResize() && moveResizePointerMode() != PositionCenter;
     }
     /**
      * Cursor shape for move/resize mode.
      */
     CursorShape cursor() const {
         return m_moveResize.cursor;
     }
 
     virtual bool hasStrut() const;
 
     void setModal(bool modal);
     bool isModal() const;
 
     /**
      * Determines the mouse command for the given @p button in the current state.
      *
      * The @p handled argument specifies whether the button was handled or not.
      * This value should be used to determine whether the mouse button should be
      * passed to the AbstractClient or being filtered out.
      */
     Options::MouseCommand getMouseCommand(Qt::MouseButton button, bool *handled) const;
     Options::MouseCommand getWheelCommand(Qt::Orientation orientation, bool *handled) const;
 
     // decoration related
     KDecoration2::Decoration *decoration() {
         return m_decoration.decoration;
     }
     const KDecoration2::Decoration *decoration() const {
         return m_decoration.decoration;
     }
     bool isDecorated() const {
         return m_decoration.decoration != nullptr;
     }
     QPointer<Decoration::DecoratedClientImpl> decoratedClient() const;
     void setDecoratedClient(QPointer<Decoration::DecoratedClientImpl> client);
     bool decorationHasAlpha() const;
     void triggerDecorationRepaint();
     virtual void layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const;
     void processDecorationMove(const QPoint &localPos, const QPoint &globalPos);
     bool processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu = false);
     void processDecorationButtonRelease(QMouseEvent *event);
 
     /**
      * TODO: fix boolean traps
      */
     virtual void updateDecoration(bool check_workspace_pos, bool force = false) = 0;
 
     /**
      * Returns whether the window provides context help or not. If it does,
      * you should show a help menu item or a help button like '?' and call
      * contextHelp() if this is invoked.
      *
      * Default implementation returns @c false.
      * @see showContextHelp;
      */
     virtual bool providesContextHelp() const;
 
     /**
      * Invokes context help on the window. Only works if the window
      * actually provides context help.
      *
      * Default implementation does nothing.
      *
      * @see providesContextHelp()
      */
     virtual void showContextHelp();
 
     QRect inputGeometry() const override;
 
     /**
      * @returns the geometry of the virtual keyboard
      * This geometry is in global coordinates
      */
     QRect virtualKeyboardGeometry() const;
 
     /**
      * Sets the geometry of the virtual keyboard, The window may resize itself in order to make space for the keybaord
      * This geometry is in global coordinates
      */
     void setVirtualKeyboardGeometry(const QRect &geo);
 
     /**
      * Restores the AbstractClient after it had been hidden due to show on screen edge functionality.
      * The AbstractClient also gets raised (e.g. Panel mode windows can cover) and the AbstractClient
      * gets informed in a window specific way that it is shown and raised again.
      */
     virtual void showOnScreenEdge() = 0;
 
     QByteArray desktopFileName() const {
         return m_desktopFileName;
     }
 
     /**
      * Tries to terminate the process of this AbstractClient.
      *
      * Implementing subclasses can perform a windowing system solution for terminating.
      */
     virtual void killWindow() = 0;
     virtual void destroyClient() = 0;
 
     enum class SameApplicationCheck {
         RelaxedForActive = 1 << 0,
         AllowCrossProcesses = 1 << 1
     };
     Q_DECLARE_FLAGS(SameApplicationChecks, SameApplicationCheck)
     static bool belongToSameApplication(const AbstractClient* c1, const AbstractClient* c2, SameApplicationChecks checks = SameApplicationChecks());
 
     bool hasApplicationMenu() const;
     bool applicationMenuActive() const {
         return m_applicationMenuActive;
     }
     void setApplicationMenuActive(bool applicationMenuActive);
 
     QString applicationMenuServiceName() const {
         return m_applicationMenuServiceName;
     }
     QString applicationMenuObjectPath() const {
         return m_applicationMenuObjectPath;
     }
     QString colorScheme() const {
         return m_colorScheme;
     }
 
     /**
      * Request showing the application menu bar
      * @param actionId The DBus menu ID of the action that should be highlighted, 0 for the root menu
      */
     void showApplicationMenu(int actionId);
 
     bool unresponsive() const;
 
     virtual bool isInitialPositionSet() const {
         return false;
     }
 
     /**
      * Default implementation returns @c null.
      * Mostly intended for X11 clients, from EWMH:
      * @verbatim
      * If the WM_TRANSIENT_FOR property is set to None or Root window, the window should be
      * treated as a transient for all other windows in the same group. It has been noted that this
      * is a slight ICCCM violation, but as this behavior is pretty standard for many toolkits and
      * window managers, and is extremely unlikely to break anything, it seems reasonable to document
      * it as standard.
      * @endverbatim
      */
     virtual bool groupTransient() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual const Group *group() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual Group *group();
 
     /**
      * Returns whether this is an internal client.
      *
      * Internal clients are created by KWin and used for special purpose windows,
      * like the task switcher, etc.
      *
      * Default implementation returns @c false.
      */
     virtual bool isInternal() const;
 
     /**
      * Returns whether window rules can be applied to this client.
      *
      * Default implementation returns @c true.
      */
     virtual bool supportsWindowRules() const;
 
     /**
      * Return window management interface
      */
     KWaylandServer::PlasmaWindowInterface *windowManagementInterface() const {
         return m_windowManagementInterface;
     }
 
 public Q_SLOTS:
     virtual void closeWindow() = 0;
 
 Q_SIGNALS:
     void fullScreenChanged();
     void skipTaskbarChanged();
     void skipPagerChanged();
     void skipSwitcherChanged();
     void iconChanged();
     void activeChanged();
     void keepAboveChanged(bool);
     void keepBelowChanged(bool);
     /**
      * Emitted whenever the demands attention state changes.
      */
     void demandsAttentionChanged();
     void desktopPresenceChanged(KWin::AbstractClient*, int); // to be forwarded by Workspace
     void desktopChanged();
     void x11DesktopIdsChanged();
     void shadeChanged();
     void minimizedChanged();
     void clientMinimized(KWin::AbstractClient* client, bool animate);
     void clientUnminimized(KWin::AbstractClient* client, bool animate);
     void paletteChanged(const QPalette &p);
     void colorSchemeChanged();
     void captionChanged();
     void clientMaximizedStateChanged(KWin::AbstractClient*, MaximizeMode);
     void clientMaximizedStateChanged(KWin::AbstractClient* c, bool h, bool v);
     void transientChanged();
     void modalChanged();
     void quickTileModeChanged();
     void moveResizedChanged();
     void moveResizeCursorChanged(CursorShape);
     void clientStartUserMovedResized(KWin::AbstractClient*);
     void clientStepUserMovedResized(KWin::AbstractClient *, const QRect&);
     void clientFinishUserMovedResized(KWin::AbstractClient*);
     void closeableChanged(bool);
     void minimizeableChanged(bool);
     void shadeableChanged(bool);
     void maximizeableChanged(bool);
     void desktopFileNameChanged();
     void applicationMenuChanged();
     void hasApplicationMenuChanged(bool);
     void applicationMenuActiveChanged(bool);
     void unresponsiveChanged(bool);
 
 protected:
     AbstractClient();
     void setFirstInTabBox(bool enable) {
         m_firstInTabBox = enable;
     }
     void setIcon(const QIcon &icon);
     void startAutoRaise();
     void autoRaise();
     /**
      * Whether the window accepts focus.
      * The difference to wantsInput is that the implementation should not check rules and return
      * what the window effectively supports.
      */
     virtual bool acceptsFocus() const = 0;
     /**
      * Called from setActive once the active value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetActive();
     /**
      * Called from setKeepAbove once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepAbove();
     /**
      * Called from setKeepBelow once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepBelow();
+    /**
+     * Called from setShade() once the shadeMode value got updated, but before the changed signal
+     * is emitted.
+     *
+     * Default implementation does nothing.
+     */
+    virtual void doSetShade(ShadeMode previousShadeMode);
     /**
      * Called from setDeskop once the desktop value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetDesktop();
     /**
      * Called from @ref minimize and @ref unminimize once the minimized value got updated, but before the
      * changed signal is emitted.
      *
      * Default implementation does nothig.
      */
     virtual void doMinimize();
     virtual bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const = 0;
 
     virtual void doSetSkipTaskbar();
     virtual void doSetSkipPager();
     virtual void doSetSkipSwitcher();
     virtual void doSetDemandsAttention();
 
     void setupWindowManagementInterface();
     void destroyWindowManagementInterface();
 
     void updateColorScheme(QString path);
     virtual void updateColorScheme() = 0;
 
     void setTransientFor(AbstractClient *transientFor);
     /**
      * Just removes the @p cl from the transients without any further checks.
      */
     void removeTransientFromList(AbstractClient* cl);
 
     Layer belongsToLayer() const;
     virtual bool belongsToDesktop() const;
     void invalidateLayer();
     bool isActiveFullScreen() const;
     virtual Layer layerForDock() const;
 
     // electric border / quick tiling
     void setElectricBorderMode(QuickTileMode mode);
     QuickTileMode electricBorderMode() const {
         return m_electricMode;
     }
     void setElectricBorderMaximizing(bool maximizing);
     bool isElectricBorderMaximizing() const {
         return m_electricMaximizing;
     }
     QRect electricBorderMaximizeGeometry(QPoint pos, int desktop);
     void updateQuickTileMode(QuickTileMode newMode) {
         m_quickTileMode = newMode;
     }
 
     // geometry handling
     void checkOffscreenPosition(QRect *geom, const QRect &screenArea);
     int borderLeft() const;
     int borderRight() const;
     int borderTop() const;
     int borderBottom() const;
     virtual void changeMaximize(bool horizontal, bool vertical, bool adjust);
     void setGeometryRestore(const QRect &rect);
 
     /**
      * Called from move after updating the geometry. Can be reimplemented to perform specific tasks.
      * The base implementation does nothing.
      */
     virtual void doMove(int x, int y);
     void blockGeometryUpdates(bool block);
     void blockGeometryUpdates();
     void unblockGeometryUpdates();
     bool areGeometryUpdatesBlocked() const;
     enum PendingGeometry_t {
         PendingGeometryNone,
         PendingGeometryNormal,
         PendingGeometryForced
     };
     PendingGeometry_t pendingGeometryUpdate() const;
     void setPendingGeometryUpdate(PendingGeometry_t update);
     QRect bufferGeometryBeforeUpdateBlocking() const;
     QRect frameGeometryBeforeUpdateBlocking() const;
     void updateGeometryBeforeUpdateBlocking();
     /**
      * Schedules a repaint for the visibleRect before and after a
      * geometry update. The current visibleRect is stored for the
      * next time this method is called as the before geometry.
      */
     void addRepaintDuringGeometryUpdates();
 
     /**
      * @returns whether the Client is currently in move resize mode
      */
     bool isMoveResize() const {
         return m_moveResize.enabled;
     }
     /**
      * Sets whether the Client is in move resize mode to @p enabled.
      */
     void setMoveResize(bool enabled) {
         m_moveResize.enabled = enabled;
     }
     /**
      * @returns whether the move resize mode is unrestricted.
      */
     bool isUnrestrictedMoveResize() const {
         return m_moveResize.unrestricted;
     }
     /**
      * Sets whether move resize mode is unrestricted to @p set.
      */
     void setUnrestrictedMoveResize(bool set) {
         m_moveResize.unrestricted = set;
     }
     QPoint moveOffset() const {
         return m_moveResize.offset;
     }
     void setMoveOffset(const QPoint &offset) {
         m_moveResize.offset = offset;
     }
     QPoint invertedMoveOffset() const {
         return m_moveResize.invertedOffset;
     }
     void setInvertedMoveOffset(const QPoint &offset) {
         m_moveResize.invertedOffset = offset;
     }
     QRect initialMoveResizeGeometry() const {
         return m_moveResize.initialGeometry;
     }
     /**
      * Sets the initial move resize geometry to the current geometry.
      */
     void updateInitialMoveResizeGeometry();
     QRect moveResizeGeometry() const {
         return m_moveResize.geometry;
     }
     void setMoveResizeGeometry(const QRect &geo) {
         m_moveResize.geometry = geo;
     }
     Position moveResizePointerMode() const {
         return m_moveResize.pointer;
     }
     void setMoveResizePointerMode(Position mode) {
         m_moveResize.pointer = mode;
     }
     bool isMoveResizePointerButtonDown() const {
         return m_moveResize.buttonDown;
     }
     void setMoveResizePointerButtonDown(bool down) {
         m_moveResize.buttonDown = down;
     }
     int moveResizeStartScreen() const {
         return m_moveResize.startScreen;
     }
     void checkUnrestrictedMoveResize();
     /**
      * Sets an appropriate cursor shape for the logical mouse position.
      */
     void updateCursor();
     void startDelayedMoveResize();
     void stopDelayedMoveResize();
     bool startMoveResize();
     /**
      * Called from startMoveResize.
      *
      * Implementing classes should return @c false if starting move resize should
      * get aborted. In that case startMoveResize will also return @c false.
      *
      * Base implementation returns @c true.
      */
     virtual bool doStartMoveResize();
     void finishMoveResize(bool cancel);
     /**
      * Leaves the move resize mode.
      *
      * Inheriting classes must invoke the base implementation which
      * ensures that the internal mode is properly ended.
      */
     virtual void leaveMoveResize();
     virtual void positionGeometryTip();
     void performMoveResize();
     /**
      * Called from performMoveResize() after actually performing the change of geometry.
      * Implementing subclasses can perform windowing system specific handling here.
      *
      * Default implementation does nothing.
      */
     virtual void doPerformMoveResize();
     /*
      * Checks if the mouse cursor is near the edge of the screen and if so
      * activates quick tiling or maximization
      */
     void checkQuickTilingMaximizationZones(int xroot, int yroot);
     /**
      * Whether a sync request is still pending.
      * Default implementation returns @c false.
      */
     virtual bool isWaitingForMoveResizeSync() const;
     /**
      * Called during handling a resize. Implementing subclasses can use this
      * method to perform windowing system specific syncing.
      *
      * Default implementation does nothing.
      */
     virtual void doResizeSync();
     void handleMoveResize(int x, int y, int x_root, int y_root);
     void handleMoveResize(const QPoint &local, const QPoint &global);
     void dontMoveResize();
 
     virtual QSize resizeIncrements() const;
 
     /**
      * Returns the position depending on the Decoration's section under mouse.
      * If no decoration it returns PositionCenter.
      */
     Position mousePosition() const;
 
     static bool haveResizeEffect() {
         return s_haveResizeEffect;
     }
     static void updateHaveResizeEffect();
     static void resetHaveResizeEffect() {
         s_haveResizeEffect = false;
     }
 
     void setDecoration(KDecoration2::Decoration *decoration) {
         m_decoration.decoration = decoration;
     }
     virtual void createDecoration(const QRect &oldGeometry);
     virtual void destroyDecoration();
     void startDecorationDoubleClickTimer();
     void invalidateDecorationDoubleClickTimer();
 
     void setDesktopFileName(QByteArray name);
     QString iconFromDesktopFile() const;
 
     void updateApplicationMenuServiceName(const QString &serviceName);
     void updateApplicationMenuObjectPath(const QString &objectPath);
 
     void setUnresponsive(bool unresponsive);
 
     virtual void setShortcutInternal();
     QString shortcutCaptionSuffix() const;
     virtual void updateCaption() = 0;
 
     /**
      * Looks for another AbstractClient with same captionNormal and captionSuffix.
      * If no such AbstractClient exists @c nullptr is returned.
      */
     AbstractClient *findClientWithSameCaption() const;
 
     void finishWindowRules();
     void discardTemporaryRules();
 
     bool tabTo(AbstractClient *other, bool behind, bool activate);
 
+    void startShadeHoverTimer();
+    void startShadeUnhoverTimer();
+
+private Q_SLOTS:
+    void shadeHover();
+    void shadeUnhover();
+
 private:
     void handlePaletteChange();
     QSharedPointer<TabBox::TabBoxClientImpl> m_tabBoxClient;
     bool m_firstInTabBox = false;
     bool m_skipTaskbar = false;
     /**
      * Unaffected by KWin
      */
     bool m_originalSkipTaskbar = false;
     bool m_skipPager = false;
     bool m_skipSwitcher = false;
     QIcon m_icon;
     bool m_active = false;
     bool m_keepAbove = false;
     bool m_keepBelow = false;
     bool m_demandsAttention = false;
     bool m_minimized = false;
     QTimer *m_autoRaiseTimer = nullptr;
+    QTimer *m_shadeHoverTimer = nullptr;
+    ShadeMode m_shadeMode = ShadeNone;
     QVector <VirtualDesktop *> m_desktops;
 
     QString m_colorScheme;
     std::shared_ptr<Decoration::DecorationPalette> m_palette;
     static QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> s_palettes;
     static std::shared_ptr<Decoration::DecorationPalette> s_defaultPalette;
 
     KWaylandServer::PlasmaWindowInterface *m_windowManagementInterface = nullptr;
 
     AbstractClient *m_transientFor = nullptr;
     QList<AbstractClient*> m_transients;
     bool m_modal = false;
     Layer m_layer = UnknownLayer;
 
     // electric border/quick tiling
     QuickTileMode m_electricMode = QuickTileFlag::None;
     bool m_electricMaximizing = false;
     // The quick tile mode of this window.
     int m_quickTileMode = int(QuickTileFlag::None);
     QTimer *m_electricMaximizingDelay = nullptr;
 
     // geometry
     int m_blockGeometryUpdates = 0; // > 0 = New geometry is remembered, but not actually set
     PendingGeometry_t m_pendingGeometryUpdate = PendingGeometryNone;
     friend class GeometryUpdatesBlocker;
     QRect m_visibleRectBeforeGeometryUpdate;
     QRect m_bufferGeometryBeforeUpdateBlocking;
     QRect m_frameGeometryBeforeUpdateBlocking;
     QRect m_virtualKeyboardGeometry;
     QRect m_keyboardGeometryRestore;
     QRect m_maximizeGeometryRestore;
 
     struct {
         bool enabled = false;
         bool unrestricted = false;
         QPoint offset;
         QPoint invertedOffset;
         QRect initialGeometry;
         QRect geometry;
         Position pointer = PositionCenter;
         bool buttonDown = false;
         CursorShape cursor = Qt::ArrowCursor;
         int startScreen = 0;
         QTimer *delayedTimer = nullptr;
     } m_moveResize;
 
     struct {
         KDecoration2::Decoration *decoration = nullptr;
         QPointer<Decoration::DecoratedClientImpl> client;
         QElapsedTimer doubleClickTimer;
     } m_decoration;
     QByteArray m_desktopFileName;
 
     bool m_applicationMenuActive = false;
     QString m_applicationMenuServiceName;
     QString m_applicationMenuObjectPath;
 
     bool m_unresponsive = false;
 
     QKeySequence _shortcut;
 
     WindowRules m_rules;
 
     static bool s_haveResizeEffect;
 };
 
 /**
  * Helper for AbstractClient::blockGeometryUpdates() being called in pairs (true/false)
  */
 class GeometryUpdatesBlocker
 {
 public:
     explicit GeometryUpdatesBlocker(AbstractClient* c)
         : cl(c) {
         cl->blockGeometryUpdates(true);
     }
     ~GeometryUpdatesBlocker() {
         cl->blockGeometryUpdates(false);
     }
 
 private:
     AbstractClient* cl;
 };
 
 inline void AbstractClient::move(const QPoint& p, ForceGeometry_t force)
 {
     move(p.x(), p.y(), force);
 }
 
 inline const QList<AbstractClient*>& AbstractClient::transients() const
 {
     return m_transients;
 }
 
 inline bool AbstractClient::areGeometryUpdatesBlocked() const
 {
     return m_blockGeometryUpdates != 0;
 }
 
 inline void AbstractClient::blockGeometryUpdates()
 {
     m_blockGeometryUpdates++;
 }
 
 inline void AbstractClient::unblockGeometryUpdates()
 {
     m_blockGeometryUpdates--;
 }
 
 inline AbstractClient::PendingGeometry_t AbstractClient::pendingGeometryUpdate() const
 {
     return m_pendingGeometryUpdate;
 }
 
 inline void AbstractClient::setPendingGeometryUpdate(PendingGeometry_t update)
 {
     m_pendingGeometryUpdate = update;
 }
 
 }
 
 Q_DECLARE_METATYPE(KWin::AbstractClient*)
 Q_DECLARE_METATYPE(QList<KWin::AbstractClient*>)
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AbstractClient::SameApplicationChecks)
 
 #endif
diff --git a/events.cpp b/events.cpp
index 480571398..ffc96d9b2 100644
--- a/events.cpp
+++ b/events.cpp
@@ -1,1356 +1,1339 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
 
  This file contains things relevant to handling incoming events.
 
 */
 
 #include "x11client.h"
 #include "cursor.h"
 #include "focuschain.h"
 #include "netinfo.h"
 #include "workspace.h"
 #include "atoms.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "group.h"
 #include "rules.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "effects.h"
 #include "screens.h"
 #include "xcbutils.h"
 
 #include <KDecoration2/Decoration>
 
 #include <QApplication>
 #include <QDebug>
 #include <QHoverEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QStyleHints>
 #include <QWheelEvent>
 
 #include <kkeyserver.h>
 
 #include <xcb/sync.h>
 #ifdef XCB_ICCCM_FOUND
 #include <xcb/xcb_icccm.h>
 #endif
 
 #include "composite.h"
 #include "x11eventfilter.h"
 
 #include "wayland_server.h"
 #include <KWaylandServer/surface_interface.h>
 
 #ifndef XCB_GE_GENERIC
 #define XCB_GE_GENERIC 35
 typedef struct xcb_ge_generic_event_t {
     uint8_t  response_type; /**<  */
     uint8_t  extension; /**<  */
     uint16_t sequence; /**<  */
     uint32_t length; /**<  */
     uint16_t event_type; /**<  */
     uint8_t  pad0[22]; /**<  */
     uint32_t full_sequence; /**<  */
 } xcb_ge_generic_event_t;
 #endif
 
 namespace KWin
 {
 
 // ****************************************
 // Workspace
 // ****************************************
 
 static xcb_window_t findEventWindow(xcb_generic_event_t *event)
 {
     const uint8_t eventType = event->response_type & ~0x80;
     switch(eventType) {
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE:
         return reinterpret_cast<xcb_key_press_event_t*>(event)->event;
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         return reinterpret_cast<xcb_button_press_event_t*>(event)->event;
     case XCB_MOTION_NOTIFY:
         return reinterpret_cast<xcb_motion_notify_event_t*>(event)->event;
     case XCB_ENTER_NOTIFY:
     case XCB_LEAVE_NOTIFY:
         return reinterpret_cast<xcb_enter_notify_event_t*>(event)->event;
     case XCB_FOCUS_IN:
     case XCB_FOCUS_OUT:
         return reinterpret_cast<xcb_focus_in_event_t*>(event)->event;
     case XCB_EXPOSE:
         return reinterpret_cast<xcb_expose_event_t*>(event)->window;
     case XCB_GRAPHICS_EXPOSURE:
         return reinterpret_cast<xcb_graphics_exposure_event_t*>(event)->drawable;
     case XCB_NO_EXPOSURE:
         return reinterpret_cast<xcb_no_exposure_event_t*>(event)->drawable;
     case XCB_VISIBILITY_NOTIFY:
         return reinterpret_cast<xcb_visibility_notify_event_t*>(event)->window;
     case XCB_CREATE_NOTIFY:
         return reinterpret_cast<xcb_create_notify_event_t*>(event)->window;
     case XCB_DESTROY_NOTIFY:
         return reinterpret_cast<xcb_destroy_notify_event_t*>(event)->window;
     case XCB_UNMAP_NOTIFY:
         return reinterpret_cast<xcb_unmap_notify_event_t*>(event)->window;
     case XCB_MAP_NOTIFY:
         return reinterpret_cast<xcb_map_notify_event_t*>(event)->window;
     case XCB_MAP_REQUEST:
         return reinterpret_cast<xcb_map_request_event_t*>(event)->window;
     case XCB_REPARENT_NOTIFY:
         return reinterpret_cast<xcb_reparent_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_NOTIFY:
         return reinterpret_cast<xcb_configure_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_REQUEST:
         return reinterpret_cast<xcb_configure_request_event_t*>(event)->window;
     case XCB_GRAVITY_NOTIFY:
         return reinterpret_cast<xcb_gravity_notify_event_t*>(event)->window;
     case XCB_RESIZE_REQUEST:
         return reinterpret_cast<xcb_resize_request_event_t*>(event)->window;
     case XCB_CIRCULATE_NOTIFY:
     case XCB_CIRCULATE_REQUEST:
         return reinterpret_cast<xcb_circulate_notify_event_t*>(event)->window;
     case XCB_PROPERTY_NOTIFY:
         return reinterpret_cast<xcb_property_notify_event_t*>(event)->window;
     case XCB_COLORMAP_NOTIFY:
         return reinterpret_cast<xcb_colormap_notify_event_t*>(event)->window;
     case XCB_CLIENT_MESSAGE:
         return reinterpret_cast<xcb_client_message_event_t*>(event)->window;
     default:
         // extension handling
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             return reinterpret_cast<xcb_shape_notify_event_t*>(event)->affected_window;
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent()) {
             return reinterpret_cast<xcb_damage_notify_event_t*>(event)->drawable;
         }
         return XCB_WINDOW_NONE;
     }
 }
 
 QVector<QByteArray> s_xcbEerrors({
     QByteArrayLiteral("Success"),
     QByteArrayLiteral("BadRequest"),
     QByteArrayLiteral("BadValue"),
     QByteArrayLiteral("BadWindow"),
     QByteArrayLiteral("BadPixmap"),
     QByteArrayLiteral("BadAtom"),
     QByteArrayLiteral("BadCursor"),
     QByteArrayLiteral("BadFont"),
     QByteArrayLiteral("BadMatch"),
     QByteArrayLiteral("BadDrawable"),
     QByteArrayLiteral("BadAccess"),
     QByteArrayLiteral("BadAlloc"),
     QByteArrayLiteral("BadColor"),
     QByteArrayLiteral("BadGC"),
     QByteArrayLiteral("BadIDChoice"),
     QByteArrayLiteral("BadName"),
     QByteArrayLiteral("BadLength"),
     QByteArrayLiteral("BadImplementation"),
     QByteArrayLiteral("Unknown")});
 
 
 void Workspace::registerEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.append(filter);
     else
         m_eventFilters.append(filter);
 }
 
 void Workspace::unregisterEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.removeOne(filter);
     else
         m_eventFilters.removeOne(filter);
 }
 
 
 /**
  * Handles workspace specific XCB event
  */
 bool Workspace::workspaceEvent(xcb_generic_event_t *e)
 {
     const uint8_t eventType = e->response_type & ~0x80;
     if (!eventType) {
         // let's check whether it's an error from one of the extensions KWin uses
         xcb_generic_error_t *error = reinterpret_cast<xcb_generic_error_t*>(e);
         const QVector<Xcb::ExtensionData> extensions = Xcb::Extensions::self()->extensions();
         for (const auto &extension : extensions) {
             if (error->major_code == extension.majorOpcode) {
                 QByteArray errorName;
                 if (error->error_code < s_xcbEerrors.size()) {
                     errorName = s_xcbEerrors.at(error->error_code);
                 } else if (error->error_code >= extension.errorBase) {
                     const int index = error->error_code - extension.errorBase;
                     if (index >= 0 && index < extension.errorCodes.size()) {
                         errorName = extension.errorCodes.at(index);
                     }
                 }
                 if (errorName.isEmpty()) {
                     errorName = QByteArrayLiteral("Unknown");
                 }
                 qCWarning(KWIN_CORE, "XCB error: %d (%s), sequence: %d, resource id: %d, major code: %d (%s), minor code: %d (%s)",
                          int(error->error_code), errorName.constData(),
                          int(error->sequence), int(error->resource_id),
                          int(error->major_code), extension.name.constData(),
                          int(error->minor_code),
                          extension.opCodes.size() > error->minor_code ? extension.opCodes.at(error->minor_code).constData() : "Unknown");
                 return true;
             }
         }
         return false;
     }
 
     if (eventType == XCB_GE_GENERIC) {
         xcb_ge_generic_event_t *ge = reinterpret_cast<xcb_ge_generic_event_t *>(e);
 
         foreach (X11EventFilter *filter, m_genericEventFilters) {
             if (filter->extension() == ge->extension && filter->genericEventTypes().contains(ge->event_type) && filter->event(e)) {
                 return true;
             }
         }
     } else {
         foreach (X11EventFilter *filter, m_eventFilters) {
             if (filter->eventTypes().contains(eventType) && filter->event(e)) {
                 return true;
             }
         }
     }
 
     if (effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()
             && (eventType == XCB_KEY_PRESS || eventType == XCB_KEY_RELEASE))
         return false; // let Qt process it, it'll be intercepted again in eventFilter()
 
     // events that should be handled before Clients can get them
     switch (eventType) {
     case XCB_CONFIGURE_NOTIFY:
         if (reinterpret_cast<xcb_configure_notify_event_t*>(e)->event == rootWindow())
             markXStackingOrderAsDirty();
         break;
     };
 
     const xcb_window_t eventWindow = findEventWindow(e);
     if (eventWindow != XCB_WINDOW_NONE) {
         if (X11Client *c = findClient(Predicate::WindowMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::WrapperIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::FrameIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::InputIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Unmanaged* c = findUnmanaged(eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         }
     }
 
     switch (eventType) {
     case XCB_CREATE_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_create_notify_event_t*>(e);
         if (event->parent == rootWindow() &&
                 !QWidget::find(event->window) &&
                 !event->override_redirect) {
             // see comments for allowClientActivation()
             updateXTime();
             const xcb_timestamp_t t = xTime();
             xcb_change_property(connection(), XCB_PROP_MODE_REPLACE, event->window, atoms->kde_net_wm_user_creation_time, XCB_ATOM_CARDINAL, 32, 1, &t);
         }
         break;
     }
     case XCB_UNMAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_unmap_notify_event_t*>(e);
         return (event->event != event->window);   // hide wm typical event from Qt
     }
     case XCB_REPARENT_NOTIFY: {
         //do not confuse Qt with these events. After all, _we_ are the
         //window manager who does the reparenting.
         return true;
     }
     case XCB_MAP_REQUEST: {
         updateXTime();
 
         const auto *event = reinterpret_cast<xcb_map_request_event_t*>(e);
         if (X11Client *c = findClient(Predicate::WindowMatch, event->window)) {
             // e->xmaprequest.window is different from e->xany.window
             // TODO this shouldn't be necessary now
             c->windowEvent(e);
             FocusChain::self()->update(c, FocusChain::Update);
         } else if ( true /*|| e->xmaprequest.parent != root */ ) {
             // NOTICE don't check for the parent being the root window, this breaks when some app unmaps
             // a window, changes something and immediately maps it back, without giving KWin
             // a chance to reparent it back to root
             // since KWin can get MapRequest only for root window children and
             // children of WindowWrapper (=clients), the check is AFAIK useless anyway
             // NOTICE: The save-set support in X11Client::mapRequestEvent() actually requires that
             // this code doesn't check the parent to be root.
             if (!createClient(event->window, false)) {
                 xcb_map_window(connection(), event->window);
                 const uint32_t values[] = { XCB_STACK_MODE_ABOVE };
                 xcb_configure_window(connection(), event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
             }
         }
         return true;
     }
     case XCB_MAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_map_notify_event_t*>(e);
         if (event->override_redirect) {
             Unmanaged* c = findUnmanaged(event->window);
             if (c == nullptr)
                 c = createUnmanaged(event->window);
             if (c) {
                 // if hasScheduledRelease is true, it means a unamp and map sequence has occurred. 
                 // since release is scheduled after map notify, this old Unmanaged will get released
                 // before KWIN has chance to remanage it again. so release it right now.
                 if (c->hasScheduledRelease()) {
                     c->release();
                     c = createUnmanaged(event->window);
                 }
                 if (c)
                     return c->windowEvent(e);
             }
         }
         return (event->event != event->window);   // hide wm typical event from Qt
     }
 
     case XCB_CONFIGURE_REQUEST: {
         const auto *event = reinterpret_cast<xcb_configure_request_event_t*>(e);
         if (event->parent == rootWindow()) {
             uint32_t values[5] = { 0, 0, 0, 0, 0};
             const uint32_t value_mask = event->value_mask
                                         & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH);
             int i = 0;
             if (value_mask & XCB_CONFIG_WINDOW_X) {
                 values[i++] = event->x;
             }
             if (value_mask & XCB_CONFIG_WINDOW_Y) {
                 values[i++] = event->y;
             }
             if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
                 values[i++] = event->width;
             }
             if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
                 values[i++] = event->height;
             }
             if (value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
                 values[i++] = event->border_width;
             }
             xcb_configure_window(connection(), event->window, value_mask, values);
             return true;
         }
         break;
     }
     case XCB_FOCUS_IN: {
         const auto *event = reinterpret_cast<xcb_focus_in_event_t*>(e);
         if (event->event == rootWindow()
                 && (event->detail == XCB_NOTIFY_DETAIL_NONE || event->detail == XCB_NOTIFY_DETAIL_POINTER_ROOT || event->detail == XCB_NOTIFY_DETAIL_INFERIOR)) {
             Xcb::CurrentInput currentInput;
             updateXTime(); // focusToNull() uses xTime(), which is old now (FocusIn has no timestamp)
             // it seems we can "loose" focus reversions when the closing client hold a grab
             // => catch the typical pattern (though we don't want the focus on the root anyway) #348935
             const bool lostFocusPointerToRoot = currentInput->focus == rootWindow() && event->detail == XCB_NOTIFY_DETAIL_INFERIOR;
             if (!currentInput.isNull() && (currentInput->focus == XCB_WINDOW_NONE || currentInput->focus == XCB_INPUT_FOCUS_POINTER_ROOT || lostFocusPointerToRoot)) {
                 //kWarning( 1212 ) << "X focus set to None/PointerRoot, reseting focus" ;
                 AbstractClient *c = mostRecentlyActivatedClient();
                 if (c != nullptr)
                     requestFocus(c, true);
                 else if (activateNextClient(nullptr))
                     ; // ok, activated
                 else
                     focusToNull();
             }
         }
     }
         // fall through
     case XCB_FOCUS_OUT:
         return true; // always eat these, they would tell Qt that KWin is the active app
     default:
         break;
     }
     return false;
 }
 
 // Used only to filter events that need to be processed by Qt first
 // (e.g. keyboard input to be composed), otherwise events are
 // handle by the XEvent filter above
 bool Workspace::workspaceEvent(QEvent* e)
 {
     if ((e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease || e->type() == QEvent::ShortcutOverride)
             && effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(static_cast< QKeyEvent* >(e));
         return true;
     }
     return false;
 }
 
 // ****************************************
 // Client
 // ****************************************
 
 /**
  * General handler for XEvents concerning the client window
  */
 bool X11Client::windowEvent(xcb_generic_event_t *e)
 {
     if (findEventWindow(e) == window()) { // avoid doing stuff on frame or wrapper
         NET::Properties dirtyProperties;
         NET::Properties2 dirtyProperties2;
         double old_opacity = opacity();
         info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
 
         if ((dirtyProperties & NET::WMName) != 0)
             fetchName();
         if ((dirtyProperties & NET::WMIconName) != 0)
             fetchIconicName();
         if ((dirtyProperties & NET::WMStrut) != 0
                 || (dirtyProperties2 & NET::WM2ExtendedStrut) != 0) {
             workspace()->updateClientArea();
         }
         if ((dirtyProperties & NET::WMIcon) != 0)
             getIcons();
         // Note there's a difference between userTime() and info->userTime()
         // info->userTime() is the value of the property, userTime() also includes
         // updates of the time done by KWin (ButtonPress on windowrapper etc.).
         if ((dirtyProperties2 & NET::WM2UserTime) != 0) {
             workspace()->setWasUserInteraction();
             updateUserTime(info->userTime());
         }
         if ((dirtyProperties2 & NET::WM2StartupId) != 0)
             startupIdChanged();
         if (dirtyProperties2 & NET::WM2Opacity) {
             if (compositing()) {
                 addRepaintFull();
                 emit opacityChanged(this, old_opacity);
             } else {
                 // forward to the frame if there's possibly another compositing manager running
                 NETWinInfo i(connection(), frameId(), rootWindow(), NET::Properties(), NET::Properties2());
                 i.setOpacity(info->opacity());
             }
         }
         if (dirtyProperties2 & NET::WM2FrameOverlap) {
             // ### Inform the decoration
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
             emit windowRoleChanged();
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
             getResourceClass();
         }
         if (dirtyProperties2.testFlag(NET::WM2BlockCompositing)) {
             setBlockingCompositing(info->isBlockingCompositing());
         }
         if (dirtyProperties2.testFlag(NET::WM2GroupLeader)) {
             checkGroup();
             updateAllowedActions(); // Group affects isMinimizable()
         }
         if (dirtyProperties2.testFlag(NET::WM2Urgency)) {
             updateUrgency();
         }
         if (dirtyProperties2 & NET::WM2OpaqueRegion) {
             getWmOpaqueRegion();
         }
         if (dirtyProperties2 & NET::WM2DesktopFileName) {
             setDesktopFileName(QByteArray(info->desktopFileName()));
         }
         if (dirtyProperties2 & NET::WM2GTKFrameExtents) {
             setClientFrameExtents(info->gtkFrameExtents());
         }
     }
 
     const uint8_t eventType = e->response_type & ~0x80;
     switch(eventType) {
     case XCB_UNMAP_NOTIFY:
         unmapNotifyEvent(reinterpret_cast<xcb_unmap_notify_event_t*>(e));
         break;
     case XCB_DESTROY_NOTIFY:
         destroyNotifyEvent(reinterpret_cast<xcb_destroy_notify_event_t*>(e));
         break;
     case XCB_MAP_REQUEST:
         // this one may pass the event to workspace
         return mapRequestEvent(reinterpret_cast<xcb_map_request_event_t*>(e));
     case XCB_CONFIGURE_REQUEST:
         configureRequestEvent(reinterpret_cast<xcb_configure_request_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_KEY_PRESS:
         updateUserTime(reinterpret_cast<xcb_key_press_event_t*>(e)->time);
         break;
     case XCB_BUTTON_PRESS: {
         const auto *event = reinterpret_cast<xcb_button_press_event_t*>(e);
         updateUserTime(event->time);
         buttonPressEvent(event->event, event->detail, event->state,
                          event->event_x, event->event_y, event->root_x, event->root_y, event->time);
         break;
     }
     case XCB_KEY_RELEASE:
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         break;
     case XCB_BUTTON_RELEASE: {
         const auto *event = reinterpret_cast<xcb_button_release_event_t*>(e);
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         buttonReleaseEvent(event->event, event->detail, event->state,
                            event->event_x, event->event_y, event->root_x, event->root_y);
         break;
     }
     case XCB_MOTION_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_motion_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_ENTER_NOTIFY: {
         auto *event = reinterpret_cast<xcb_enter_notify_event_t*>(e);
         enterNotifyEvent(event);
         // MotionNotify is guaranteed to be generated only if the mouse
         // move start and ends in the window; for cases when it only
         // starts or only ends there, Enter/LeaveNotify are generated.
         // Fake a MotionEvent in such cases to make handle of mouse
         // events simpler (Qt does that too).
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_LEAVE_NOTIFY: {
         auto *event = reinterpret_cast<xcb_leave_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         leaveNotifyEvent(event);
         // not here, it'd break following enter notify handling
         // workspace()->updateFocusMousePosition( QPoint( e->xcrossing.x_root, e->xcrossing.y_root ));
         break;
     }
     case XCB_FOCUS_IN:
         focusInEvent(reinterpret_cast<xcb_focus_in_event_t*>(e));
         break;
     case XCB_FOCUS_OUT:
         focusOutEvent(reinterpret_cast<xcb_focus_out_event_t*>(e));
         break;
     case XCB_REPARENT_NOTIFY:
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     case XCB_EXPOSE: {
         xcb_expose_event_t *event = reinterpret_cast<xcb_expose_event_t*>(e);
         if (event->window == frameId() && !Compositor::self()->isActive()) {
             // TODO: only repaint required areas
             triggerDecorationRepaint();
         }
         break;
     }
     default:
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent() && reinterpret_cast<xcb_shape_notify_event_t*>(e)->affected_window == window()) {
             detectShape(window());  // workaround for #19644
             updateShape();
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent() && reinterpret_cast<xcb_damage_notify_event_t*>(e)->drawable == frameId())
             damageNotifyEvent();
         break;
     }
     return true; // eat all events
 }
 
 /**
  * Handles map requests of the client window
  */
 bool X11Client::mapRequestEvent(xcb_map_request_event_t *e)
 {
     if (e->window != window()) {
         // Special support for the save-set feature, which is a bit broken.
         // If there's a window from one client embedded in another one,
         // e.g. using XEMBED, and the embedder suddenly loses its X connection,
         // save-set will reparent the embedded window to its closest ancestor
         // that will remains. Unfortunately, with reparenting window managers,
         // this is not the root window, but the frame (or in KWin's case,
         // it's the wrapper for the client window). In this case,
         // the wrapper will get ReparentNotify for a window it won't know,
         // which will be ignored, and then it gets MapRequest, as save-set
         // always maps. Returning true here means that Workspace::workspaceEvent()
         // will handle this MapRequest and manage this window (i.e. act as if
         // it was reparented to root window).
         if (e->parent == wrapperId())
             return false;
         return true; // no messing with frame etc.
     }
     // also copied in clientMessage()
     if (isMinimized())
         unminimize();
     if (isShade())
         setShade(ShadeNone);
     if (!isOnCurrentDesktop()) {
         if (workspace()->allowClientActivation(this))
             workspace()->activateClient(this);
         else
             demandAttention();
     }
     return true;
 }
 
 /**
  * Handles unmap notify events of the client window
  */
 void X11Client::unmapNotifyEvent(xcb_unmap_notify_event_t *e)
 {
     if (e->window != window())
         return;
     if (e->event != wrapperId()) {
         // most probably event from root window when initially reparenting
         bool ignore = true;
         if (e->event == rootWindow() && (e->response_type & 0x80))
             ignore = false; // XWithdrawWindow()
         if (ignore)
             return;
     }
 
     // check whether this is result of an XReparentWindow - client then won't be parented by wrapper
     // in this case do not release the client (causes reparent to root, removal from saveSet and what not)
     // but just destroy the client
     Xcb::Tree tree(m_client);
     xcb_window_t daddy = tree.parent();
     if (daddy == m_wrapper) {
         releaseWindow(); // unmapped from a regular client state
     } else {
         destroyClient(); // the client was moved to some other parent
     }
 }
 
 void X11Client::destroyNotifyEvent(xcb_destroy_notify_event_t *e)
 {
     if (e->window != window())
         return;
     destroyClient();
 }
 
 
 /**
  * Handles client messages for the client window
  */
 void X11Client::clientMessageEvent(xcb_client_message_event_t *e)
 {
     Toplevel::clientMessageEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     // WM_STATE
     if (e->type == atoms->wm_change_state) {
         if (e->data.data32[0] == XCB_ICCCM_WM_STATE_ICONIC)
             minimize();
         return;
     }
 }
 
 
 /**
  * Handles configure  requests of the client window
  */
 void X11Client::configureRequestEvent(xcb_configure_request_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     if (isResize() || isMove())
         return; // we have better things to do right now
 
     if (m_fullscreenMode == FullScreenNormal) { // refuse resizing of fullscreen windows
         // but allow resizing fullscreen hacks in order to let them cancel fullscreen mode
         sendSyntheticConfigureNotify();
         return;
     }
     if (isSplash()) {  // no manipulations with splashscreens either
         sendSyntheticConfigureNotify();
         return;
     }
 
     if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
         // first, get rid of a window border
         m_client.setBorderWidth(0);
     }
 
     if (e->value_mask & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_WIDTH))
         configureRequest(e->value_mask, e->x, e->y, e->width, e->height, 0, false);
 
     if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE)
         restackWindow(e->sibling, e->stack_mode, NET::FromApplication, userTime(), false);
 
     // Sending a synthetic configure notify always is fine, even in cases where
     // the ICCCM doesn't require this - it can be though of as 'the WM decided to move
     // the window later'. The client should not cause that many configure request,
     // so this should not have any significant impact. With user moving/resizing
     // the it should be optimized though (see also X11Client::setGeometry()/plainResize()/move()).
     sendSyntheticConfigureNotify();
 
     // SELI TODO accept configure requests for isDesktop windows (because kdesktop
     // may get XRANDR resize event before kwin), but check it's still at the bottom?
 }
 
 
 /**
  * Handles property changes of the client window
  */
 void X11Client::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     Toplevel::propertyNotifyEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     case XCB_ATOM_WM_NORMAL_HINTS:
         getWmNormalHints();
         break;
     case XCB_ATOM_WM_NAME:
         fetchName();
         break;
     case XCB_ATOM_WM_ICON_NAME:
         fetchIconicName();
         break;
     case XCB_ATOM_WM_TRANSIENT_FOR:
         readTransient();
         break;
     case XCB_ATOM_WM_HINTS:
         getIcons(); // because KWin::icon() uses WMHints as fallback
         break;
     default:
         if (e->atom == atoms->motif_wm_hints) {
             getMotifHints();
         } else if (e->atom == atoms->net_wm_sync_request_counter)
             getSyncCounter();
         else if (e->atom == atoms->activities)
             checkActivities();
         else if (e->atom == atoms->kde_first_in_window_list)
             updateFirstInTabBox();
         else if (e->atom == atoms->kde_color_sheme)
             updateColorScheme();
         else if (e->atom == atoms->kde_screen_edge_show)
             updateShowOnScreenEdge();
         else if (e->atom == atoms->kde_net_wm_appmenu_service_name)
             checkApplicationMenuServiceName();
         else if (e->atom == atoms->kde_net_wm_appmenu_object_path)
             checkApplicationMenuObjectPath();
         break;
     }
 }
 
 
 void X11Client::enterNotifyEvent(xcb_enter_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about entering the whole frame
 
 #define MOUSE_DRIVEN_FOCUS (!options->focusPolicyIsReasonable() || \
                             (options->focusPolicy() == Options::FocusFollowsMouse && options->isNextFocusPrefersMouse()))
     if (e->mode == XCB_NOTIFY_MODE_NORMAL || (e->mode == XCB_NOTIFY_MODE_UNGRAB && MOUSE_DRIVEN_FOCUS)) {
-
-        if (options->isShadeHover()) {
-            cancelShadeHoverTimer();
-            if (isShade()) {
-                shadeHoverTimer = new QTimer(this);
-                connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeHover()));
-                shadeHoverTimer->setSingleShot(true);
-                shadeHoverTimer->start(options->shadeHoverInterval());
-            }
-        }
 #undef MOUSE_DRIVEN_FOCUS
 
         enterEvent(QPoint(e->root_x, e->root_y));
         return;
     }
 }
 
 void X11Client::leaveNotifyEvent(xcb_leave_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about leaving the whole frame
     if (e->mode == XCB_NOTIFY_MODE_NORMAL) {
         if (!isMoveResizePointerButtonDown()) {
             setMoveResizePointerMode(PositionCenter);
             updateCursor();
         }
         bool lostMouse = !rect().contains(QPoint(e->event_x, e->event_y));
         // 'lostMouse' wouldn't work with e.g. B2 or Keramik, which have non-rectangular decorations
         // (i.e. the LeaveNotify event comes before leaving the rect and no LeaveNotify event
         // comes after leaving the rect) - so lets check if the pointer is really outside the window
 
         // TODO this still sucks if a window appears above this one - it should lose the mouse
         // if this window is another client, but not if it's a popup ... maybe after KDE3.1 :(
         // (repeat after me 'AARGHL!')
         if (!lostMouse && e->detail != XCB_NOTIFY_DETAIL_INFERIOR) {
             Xcb::Pointer pointer(frameId());
             if (!pointer || !pointer->same_screen || pointer->child == XCB_WINDOW_NONE) {
                 // really lost the mouse
                 lostMouse = true;
             }
         }
         if (lostMouse) {
             leaveEvent();
-            cancelShadeHoverTimer();
-            if (shade_mode == ShadeHover && !isMoveResize() && !isMoveResizePointerButtonDown()) {
-                shadeHoverTimer = new QTimer(this);
-                connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeUnhover()));
-                shadeHoverTimer->setSingleShot(true);
-                shadeHoverTimer->start(options->shadeHoverInterval());
-            }
             if (isDecorated()) {
                 // sending a move instead of a leave. With leave we need to send proper coords, with move it's handled internally
                 QHoverEvent leaveEvent(QEvent::HoverMove, QPointF(-1, -1), QPointF(-1, -1), Qt::NoModifier);
                 QCoreApplication::sendEvent(decoration(), &leaveEvent);
             }
         }
         if (options->focusPolicy() == Options::FocusStrictlyUnderMouse && isActive() && lostMouse) {
             workspace()->requestDelayFocus(nullptr);
         }
         return;
     }
 }
 
 #define XCapL KKeyServer::modXLock()
 #define XNumL KKeyServer::modXNumLock()
 #define XScrL KKeyServer::modXScrollLock()
 void X11Client::grabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, modifier | mods[ i ]);
 }
 
 void X11Client::ungrabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.ungrabButton(modifier | mods[ i ]);
 }
 #undef XCapL
 #undef XNumL
 #undef XScrL
 
 /**
  * Releases the passive grab for some modifier combinations when a
  * window becomes active. This helps broken X programs that
  * missinterpret LeaveNotify events in grab mode to work properly
  * (Motif, AWT, Tk, ...)
  */
 void X11Client::updateMouseGrab()
 {
     if (workspace()->globalShortcutsDisabled()) {
         m_wrapper.ungrabButton();
         // keep grab for the simple click without modifiers if needed (see below)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!(!options->isClickRaise() || not_obscured))
             grabButton(XCB_NONE);
         return;
     }
     if (isActive() && !TabBox::TabBox::self()->forcedGlobalMouseGrab()) { // see TabBox::establishTabBoxGrab()
         // first grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
         // remove the grab for no modifiers only if the window
         // is unobscured or if the user doesn't want click raise
         // (it is unobscured if it the topmost in the unconstrained stacking order, i.e. it is
         // the most recently raised window)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!options->isClickRaise() || not_obscured)
             ungrabButton(XCB_NONE);
         else
             grabButton(XCB_NONE);
         ungrabButton(XCB_MOD_MASK_SHIFT);
         ungrabButton(XCB_MOD_MASK_CONTROL);
         ungrabButton(XCB_MOD_MASK_CONTROL | XCB_MOD_MASK_SHIFT);
     } else {
         m_wrapper.ungrabButton();
         // simply grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
     }
 }
 
 static bool modKeyDown(int state) {
     const uint keyModX = (options->keyCmdAllModKey() == Qt::Key_Meta) ?
                                                     KKeyServer::modXMeta() : KKeyServer::modXAlt();
     return keyModX  && (state & KKeyServer::accelModMaskX()) == keyModX;
 }
 
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::buttonPressEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root, xcb_timestamp_t time)
 {
     if (isMoveResizePointerButtonDown()) {
         if (w == wrapperId())
             xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
 
     if (w == wrapperId() || w == frameId() || w == inputId()) {
         // FRAME neco s tohohle by se melo zpracovat, nez to dostane dekorace
         updateUserTime(time);
         const bool bModKeyHeld = modKeyDown(state);
 
         if (isSplash()
                 && button == XCB_BUTTON_INDEX_1 && !bModKeyHeld) {
             // hide splashwindow if the user clicks on it
             hideClient(true);
             if (w == wrapperId())
                 xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
 
         Options::MouseCommand com = Options::MouseNothing;
         bool was_action = false;
         if (bModKeyHeld) {
             was_action = true;
             switch(button) {
             case XCB_BUTTON_INDEX_1:
                 com = options->commandAll1();
                 break;
             case XCB_BUTTON_INDEX_2:
                 com = options->commandAll2();
                 break;
             case XCB_BUTTON_INDEX_3:
                 com = options->commandAll3();
                 break;
             case XCB_BUTTON_INDEX_4:
             case XCB_BUTTON_INDEX_5:
                 com = options->operationWindowMouseWheel(button == XCB_BUTTON_INDEX_4 ? 120 : -120);
                 break;
             }
         } else {
             if (w == wrapperId()) {
                 if (button < 4) {
                     com = getMouseCommand(x11ToQtMouseButton(button), &was_action);
                 } else if (button < 6) {
                     com = getWheelCommand(Qt::Vertical, &was_action);
                 }
             }
         }
         if (was_action) {
             bool replay = performMouseCommand(com, QPoint(x_root, y_root));
 
             if (isSpecialWindow())
                 replay = true;
 
             if (w == wrapperId())  // these can come only from a grab
                 xcb_allow_events(connection(), replay ? XCB_ALLOW_REPLAY_POINTER : XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
     }
 
     if (w == wrapperId()) { // these can come only from a grab
         xcb_allow_events(connection(), XCB_ALLOW_REPLAY_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w == inputId()) {
         x = x_root - frameGeometry().x();
         y = y_root - frameGeometry().y();
         // New API processes core events FIRST and only passes unused ones to the decoration
         QMouseEvent ev(QMouseEvent::MouseButtonPress, QPoint(x, y), QPoint(x_root, y_root),
                        x11ToQtMouseButton(button), x11ToQtMouseButtons(state), Qt::KeyboardModifiers());
         return processDecorationButtonPress(&ev, true);
     }
     if (w == frameId() && isDecorated()) {
         if (button >= 4 && button <= 7) {
             const Qt::KeyboardModifiers modifiers = x11ToQtKeyboardModifiers(state);
             // Logic borrowed from qapplication_x11.cpp
             const int delta = 120 * ((button == 4 || button == 6) ? 1 : -1);
             const bool hor = (((button == 4 || button == 5) && (modifiers & Qt::AltModifier))
                              || (button == 6 || button == 7));
 
             const QPoint angle = hor ? QPoint(delta, 0) : QPoint(0, delta);
             QWheelEvent event(QPointF(x, y),
                               QPointF(x_root, y_root),
                               QPoint(),
                               angle,
                               delta,
                               hor ? Qt::Horizontal : Qt::Vertical,
                               x11ToQtMouseButtons(state),
                               modifiers);
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted() && !hor) {
                 if (titlebarPositionUnderMouse()) {
                     performMouseCommand(options->operationTitlebarMouseWheel(delta), QPoint(x_root, y_root));
                 }
             }
         } else {
             QMouseEvent event(QEvent::MouseButtonPress, QPointF(x, y), QPointF(x_root, y_root),
                             x11ToQtMouseButton(button), x11ToQtMouseButtons(state), x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted()) {
                 processDecorationButtonPress(&event);
             }
         }
         return true;
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::buttonReleaseEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated()) {
         // wheel handled on buttonPress
         if (button < 4 || button > 7) {
             QMouseEvent event(QEvent::MouseButtonRelease,
                               QPointF(x, y),
                               QPointF(x_root, y_root),
                               x11ToQtMouseButton(button),
                               x11ToQtMouseButtons(state) & ~x11ToQtMouseButton(button),
                               x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (event.isAccepted() || !titlebarPositionUnderMouse()) {
                 invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
             }
         }
     }
     if (w == wrapperId()) {
         xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true;
     if (w == frameId() && workspace()->userActionsMenu() && workspace()->userActionsMenu()->isShown()) {
         const_cast<UserActionsMenu*>(workspace()->userActionsMenu())->grabInput();
     }
     x = this->x(); // translate from grab window to local coords
     y = this->y();
 
     // Check whether other buttons are still left pressed
     int buttonMask = XCB_BUTTON_MASK_1 | XCB_BUTTON_MASK_2 | XCB_BUTTON_MASK_3;
     if (button == XCB_BUTTON_INDEX_1)
         buttonMask &= ~XCB_BUTTON_MASK_1;
     else if (button == XCB_BUTTON_INDEX_2)
         buttonMask &= ~XCB_BUTTON_MASK_2;
     else if (button == XCB_BUTTON_INDEX_3)
         buttonMask &= ~XCB_BUTTON_MASK_3;
 
     if ((state & buttonMask) == 0) {
         endMoveResize();
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::motionNotifyEvent(xcb_window_t w, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated() && !isMinimized()) {
         // TODO Mouse move event dependent on state
         QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
         QCoreApplication::instance()->sendEvent(decoration(), &event);
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true; // care only about the whole frame
     if (!isMoveResizePointerButtonDown()) {
         if (w == inputId()) {
             int x = x_root - frameGeometry().x();// + padding_left;
             int y = y_root - frameGeometry().y();// + padding_top;
 
             if (isDecorated()) {
                 QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
                 QCoreApplication::instance()->sendEvent(decoration(), &event);
             }
         }
         Position newmode = modKeyDown(state) ? PositionCenter : mousePosition();
         if (newmode != moveResizePointerMode()) {
             setMoveResizePointerMode(newmode);
             updateCursor();
         }
         return false;
     }
     if (w == moveResizeGrabWindow()) {
         x = this->x(); // translate from grab window to local coords
         y = this->y();
     }
 
     handleMoveResize(QPoint(x, y), QPoint(x_root, y_root));
     return true;
 }
 
 void X11Client::focusInEvent(xcb_focus_in_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_UNGRAB)
         return; // we don't care
     if (e->detail == XCB_NOTIFY_DETAIL_POINTER)
         return;  // we don't care
     if (!isShown(false) || !isOnCurrentDesktop())    // we unmapped it, but it got focus meanwhile ->
         return;            // activateNextClient() already transferred focus elsewhere
     workspace()->forEachClient([](X11Client *client) {
         client->cancelFocusOutTimer();
     });
     // check if this client is in should_get_focus list or if activation is allowed
     bool activate =  workspace()->allowClientActivation(this, -1U, true);
     workspace()->gotFocusIn(this);   // remove from should_get_focus list
     if (activate)
         setActive(true);
     else {
         workspace()->restoreFocus();
         demandAttention();
     }
 }
 
 void X11Client::focusOutEvent(xcb_focus_out_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_GRAB)
         return; // we don't care
     if (isShade())
         return; // here neither
     if (e->detail != XCB_NOTIFY_DETAIL_NONLINEAR
             && e->detail != XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL)
         // SELI check all this
         return; // hack for motif apps like netscape
     if (QApplication::activePopupWidget())
         return;
 
     // When a client loses focus, FocusOut events are usually immediatelly
     // followed by FocusIn events for another client that gains the focus
     // (unless the focus goes to another screen, or to the nofocus widget).
     // Without this check, the former focused client would have to be
     // deactivated, and after that, the new one would be activated, with
     // a short time when there would be no active client. This can cause
     // flicker sometimes, e.g. when a fullscreen is shown, and focus is transferred
     // from it to its transient, the fullscreen would be kept in the Active layer
     // at the beginning and at the end, but not in the middle, when the active
     // client would be temporarily none (see X11Client::belongToLayer() ).
     // Therefore the setActive(false) call is moved to the end of the current
     // event queue. If there is a matching FocusIn event in the current queue
     // this will be processed before the setActive(false) call and the activation
     // of the Client which gained FocusIn will automatically deactivate the
     // previously active client.
     if (!m_focusOutTimer) {
         m_focusOutTimer = new QTimer(this);
         m_focusOutTimer->setSingleShot(true);
         m_focusOutTimer->setInterval(0);
         connect(m_focusOutTimer, &QTimer::timeout, [this]() {
             setActive(false);
         });
     }
     m_focusOutTimer->start();
 }
 
 // performs _NET_WM_MOVERESIZE
 void X11Client::NETMoveResize(int x_root, int y_root, NET::Direction direction)
 {
     if (direction == NET::Move) {
         // move cursor to the provided position to prevent the window jumping there on first movement
         // the expectation is that the cursor is already at the provided position,
         // thus it's more a safety measurement
         Cursors::self()->mouse()->setPos(QPoint(x_root, y_root));
         performMouseCommand(Options::MouseMove, QPoint(x_root, y_root));
     } else if (isMoveResize() && direction == NET::MoveResizeCancel) {
         finishMoveResize(true);
         setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction >= NET::TopLeft && direction <= NET::Left) {
         static const Position convert[] = {
             PositionTopLeft,
             PositionTop,
             PositionTopRight,
             PositionRight,
             PositionBottomRight,
             PositionBottom,
             PositionBottomLeft,
             PositionLeft
         };
         if (!isResizable() || isShade())
             return;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(x_root - x(), y_root - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         setMoveResizePointerMode(convert[ direction ]);
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction == NET::KeyboardMove) {
         // ignore mouse coordinates given in the message, mouse position is used by the moving algorithm
         Cursors::self()->mouse()->setPos(frameGeometry().center());
         performMouseCommand(Options::MouseUnrestrictedMove, frameGeometry().center());
     } else if (direction == NET::KeyboardSize) {
         // ignore mouse coordinates given in the message, mouse position is used by the resizing algorithm
         Cursors::self()->mouse()->setPos(frameGeometry().bottomRight());
         performMouseCommand(Options::MouseUnrestrictedResize, frameGeometry().bottomRight());
     }
 }
 
 void X11Client::keyPressEvent(uint key_code, xcb_timestamp_t time)
 {
     updateUserTime(time);
     AbstractClient::keyPressEvent(key_code);
 }
 
 // ****************************************
 // Unmanaged
 // ****************************************
 
 bool Unmanaged::windowEvent(xcb_generic_event_t *e)
 {
     double old_opacity = opacity();
     NET::Properties dirtyProperties;
     NET::Properties2 dirtyProperties2;
     info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
     if (dirtyProperties2 & NET::WM2Opacity) {
         if (compositing()) {
             addRepaintFull();
             emit opacityChanged(this, old_opacity);
         }
     }
     if (dirtyProperties2 & NET::WM2OpaqueRegion) {
         getWmOpaqueRegion();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
         emit windowRoleChanged();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
         getResourceClass();
     }
     const uint8_t eventType = e->response_type & ~0x80;
     switch (eventType) {
     case XCB_DESTROY_NOTIFY:
         release(ReleaseReason::Destroyed);
         break;
     case XCB_UNMAP_NOTIFY:{
         workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
 
         // unmap notify might have been emitted due to a destroy notify
         // but unmap notify gets emitted before the destroy notify, nevertheless at this
         // point the window is already destroyed. This means any XCB request with the window
         // will cause an error.
         // To not run into these errors we try to wait for the destroy notify. For this we
         // generate a round trip to the X server and wait a very short time span before
         // handling the release.
         updateXTime();
         // using 1 msec to not just move it at the end of the event loop but add an very short
         // timespan to cover cases like unmap() followed by destroy(). The only other way to
         // ensure that the window is not destroyed when we do the release handling is to grab
         // the XServer which we do not want to do for an Unmanaged. The timespan of 1 msec is
         // short enough to not cause problems in the close window animations.
         // It's of course still possible that we miss the destroy in which case non-fatal
         // X errors are reported to the event loop and logged by Qt.
         m_scheduledRelease = true;
         QTimer::singleShot(1, this, SLOT(release()));
         break;
     }
     case XCB_CONFIGURE_NOTIFY:
         configureNotifyEvent(reinterpret_cast<xcb_configure_notify_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     default: {
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             detectShape(window());
             addRepaintFull();
             addWorkspaceRepaint(frameGeometry());  // in case shape change removes part of this window
             emit geometryShapeChanged(this, frameGeometry());
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent())
             damageNotifyEvent();
         break;
     }
     }
     return false; // don't eat events, even our own unmanaged widgets are tracked
 }
 
 void Unmanaged::configureNotifyEvent(xcb_configure_notify_event_t *e)
 {
     if (effects)
         static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking(); // keep them on top
     QRect newgeom(e->x, e->y, e->width, e->height);
     if (newgeom != m_frameGeometry) {
         addWorkspaceRepaint(visibleRect());  // damage old area
         QRect old = m_frameGeometry;
         m_frameGeometry = newgeom;
         emit frameGeometryChanged(this, old); // update shadow region
         addRepaintFull();
         if (old.size() != m_frameGeometry.size())
             discardWindowPixmap();
         emit geometryShapeChanged(this, old);
     }
 }
 
 // ****************************************
 // Toplevel
 // ****************************************
 
 void Toplevel::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     default:
         if (e->atom == atoms->wm_client_leader)
             getWmClientLeader();
         else if (e->atom == atoms->kde_net_wm_shadow)
             updateShadow();
         else if (e->atom == atoms->kde_skip_close_animation)
             getSkipCloseAnimation();
         break;
     }
 }
 
 void Toplevel::clientMessageEvent(xcb_client_message_event_t *e)
 {
     if (e->type == atoms->wl_surface_id) {
         m_surfaceId = e->data.data32[0];
         if (auto w = waylandServer()) {
             if (auto s = KWaylandServer::SurfaceInterface::get(m_surfaceId, w->xWaylandConnection())) {
                 setSurface(s);
             }
         }
         emit surfaceIdChanged(m_surfaceId);
     }
 }
 
 } // namespace
diff --git a/tabbox/tabbox.cpp b/tabbox/tabbox.cpp
index c9b031d9d..87de23fc5 100644
--- a/tabbox/tabbox.cpp
+++ b/tabbox/tabbox.cpp
@@ -1,1539 +1,1535 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 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/>.
 *********************************************************************/
 
 //#define QT_CLEAN_NAMESPACE
 // own
 #include "tabbox.h"
 // tabbox
 #include "tabbox/clientmodel.h"
 #include "tabbox/desktopmodel.h"
 #include "tabbox/tabboxconfig.h"
 #include "tabbox/desktopchain.h"
 #include "tabbox/tabbox_logging.h"
 #include "tabbox/x11_filter.h"
 // kwin
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "x11client.h"
 #include "effects.h"
 #include "input.h"
 #include "keyboard_input.h"
 #include "pointer_input.h"
 #include "focuschain.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "unmanaged.h"
 #include "virtualdesktops.h"
 #include "workspace.h"
 #include "xcbutils.h"
 // Qt
 #include <QAction>
 #include <QKeyEvent>
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <kkeyserver.h>
 // X11
 #include <X11/keysym.h>
 #include <X11/keysymdef.h>
 // xcb
 #include <xcb/xcb_keysyms.h>
 
 // specify externals before namespace
 
 namespace KWin
 {
 
 namespace TabBox
 {
 
 TabBoxHandlerImpl::TabBoxHandlerImpl(TabBox* tabBox)
     : TabBoxHandler(tabBox)
     , m_tabBox(tabBox)
     , m_desktopFocusChain(new DesktopChainManager(this))
 {
     // connects for DesktopFocusChainManager
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(vds, SIGNAL(countChanged(uint,uint)), m_desktopFocusChain, SLOT(resize(uint,uint)));
     connect(vds, SIGNAL(currentChanged(uint,uint)), m_desktopFocusChain, SLOT(addDesktop(uint,uint)));
 #ifdef KWIN_BUILD_ACTIVITIES
     if (Activities::self()) {
         connect(Activities::self(), SIGNAL(currentChanged(QString)), m_desktopFocusChain, SLOT(useChain(QString)));
     }
 #endif
 }
 
 TabBoxHandlerImpl::~TabBoxHandlerImpl()
 {
 }
 
 int TabBoxHandlerImpl::activeScreen() const
 {
     return screens()->current();
 }
 
 int TabBoxHandlerImpl::currentDesktop() const
 {
     return VirtualDesktopManager::self()->current();
 }
 
 QString TabBoxHandlerImpl::desktopName(TabBoxClient* client) const
 {
     if (TabBoxClientImpl* c = static_cast< TabBoxClientImpl* >(client)) {
         if (!c->client()->isOnAllDesktops())
             return VirtualDesktopManager::self()->name(c->client()->desktop());
     }
     return VirtualDesktopManager::self()->name(VirtualDesktopManager::self()->current());
 }
 
 QString TabBoxHandlerImpl::desktopName(int desktop) const
 {
     return VirtualDesktopManager::self()->name(desktop);
 }
 
 QWeakPointer<TabBoxClient> TabBoxHandlerImpl::nextClientFocusChain(TabBoxClient* client) const
 {
     if (TabBoxClientImpl* c = static_cast< TabBoxClientImpl* >(client)) {
         auto next = FocusChain::self()->nextMostRecentlyUsed(c->client());
         if (next)
             return next->tabBoxClient();
     }
     return QWeakPointer<TabBoxClient>();
 }
 
 QWeakPointer< TabBoxClient > TabBoxHandlerImpl::firstClientFocusChain() const
 {
     if (auto c = FocusChain::self()->firstMostRecentlyUsed()) {
         return QWeakPointer<TabBoxClient>(c->tabBoxClient());
     } else {
         return QWeakPointer<TabBoxClient>();
     }
 }
 
 bool TabBoxHandlerImpl::isInFocusChain(TabBoxClient *client) const
 {
     if (TabBoxClientImpl *c = static_cast<TabBoxClientImpl*>(client)) {
         return FocusChain::self()->contains(c->client());
     }
     return false;
 }
 
 int TabBoxHandlerImpl::nextDesktopFocusChain(int desktop) const
 {
     return m_desktopFocusChain->next(desktop);
 }
 
 int TabBoxHandlerImpl::numberOfDesktops() const
 {
     return VirtualDesktopManager::self()->count();
 }
 
 QWeakPointer<TabBoxClient> TabBoxHandlerImpl::activeClient() const
 {
     if (Workspace::self()->activeClient())
         return Workspace::self()->activeClient()->tabBoxClient();
     else
         return QWeakPointer<TabBoxClient>();
 }
 
 bool TabBoxHandlerImpl::checkDesktop(TabBoxClient* client, int desktop) const
 {
     auto current = (static_cast< TabBoxClientImpl* >(client))->client();
 
     switch (config().clientDesktopMode()) {
     case TabBoxConfig::AllDesktopsClients:
         return true;
     case TabBoxConfig::ExcludeCurrentDesktopClients:
         return !current->isOnDesktop(desktop);
     default:       // TabBoxConfig::OnlyCurrentDesktopClients
         return current->isOnDesktop(desktop);
     }
 }
 
 bool TabBoxHandlerImpl::checkActivity(TabBoxClient* client) const
 {
     auto current = (static_cast< TabBoxClientImpl* >(client))->client();
 
     switch (config().clientActivitiesMode()) {
     case TabBoxConfig::AllActivitiesClients:
         return true;
     case TabBoxConfig::ExcludeCurrentActivityClients:
         return !current->isOnCurrentActivity();
     default:       // TabBoxConfig::OnlyCurrentActivityClients
         return current->isOnCurrentActivity();
     }
 }
 
 bool TabBoxHandlerImpl::checkApplications(TabBoxClient* client) const
 {
     auto current = (static_cast< TabBoxClientImpl* >(client))->client();
     TabBoxClientImpl* c;
     QListIterator< QWeakPointer<TabBoxClient> > i(clientList());
 
     switch (config().clientApplicationsMode()) {
     case TabBoxConfig::OneWindowPerApplication:
         // check if the list already contains an entry of this application
         while (i.hasNext()) {
             QSharedPointer<TabBoxClient> client = i.next().toStrongRef();
             if (!client) {
                 continue;
             }
             if ((c = dynamic_cast< TabBoxClientImpl* >(client.data()))) {
                 if (AbstractClient::belongToSameApplication(c->client(), current, AbstractClient::SameApplicationCheck::AllowCrossProcesses)) {
                     return false;
                 }
             }
 	}
         return true;
     case TabBoxConfig::AllWindowsCurrentApplication: {
         QSharedPointer<TabBoxClient> pointer = tabBox->activeClient().toStrongRef();
         if (!pointer) {
             return false;
         }
         if ((c = dynamic_cast< TabBoxClientImpl* >(pointer.data()))) {
             if (AbstractClient::belongToSameApplication(c->client(), current, AbstractClient::SameApplicationCheck::AllowCrossProcesses)) {
                 return true;
             }
         }
         return false;
     }
     default:       // TabBoxConfig::AllWindowsAllApplications
       return true;
     }
 }
 
 bool TabBoxHandlerImpl::checkMinimized(TabBoxClient* client) const
 {
     switch (config().clientMinimizedMode()) {
     case TabBoxConfig::ExcludeMinimizedClients:
         return !client->isMinimized();
     case TabBoxConfig::OnlyMinimizedClients:
         return client->isMinimized();
     default:       // TabBoxConfig::IgnoreMinimizedStatus
         return true;
     }
 }
 
 bool TabBoxHandlerImpl::checkMultiScreen(TabBoxClient* client) const
 {
     auto current = (static_cast< TabBoxClientImpl* >(client))->client();
 
     switch (config().clientMultiScreenMode()) {
     case TabBoxConfig::IgnoreMultiScreen:
         return true;
     case TabBoxConfig::ExcludeCurrentScreenClients:
         return current->screen() != screens()->current();
     default:       // TabBoxConfig::OnlyCurrentScreenClients
         return current->screen() == screens()->current();
     }
 }
 
 QWeakPointer<TabBoxClient> TabBoxHandlerImpl::clientToAddToList(TabBoxClient* client, int desktop) const
 {
     if (!client) {
         return QWeakPointer<TabBoxClient>();
     }
     AbstractClient* ret = nullptr;
     AbstractClient* current = (static_cast< TabBoxClientImpl* >(client))->client();
 
     bool addClient = checkDesktop(client, desktop)
                   && checkActivity(client)
                   && checkApplications(client)
                   && checkMinimized(client)
                   && checkMultiScreen(client);
     addClient = addClient && current->wantsTabFocus() && !current->skipSwitcher();
     if (addClient) {
         // don't add windows that have modal dialogs
         AbstractClient* modal = current->findModal();
         if (modal == nullptr || modal == current)
             ret = current;
         else if (!clientList().contains(modal->tabBoxClient()))
             ret = modal;
         else {
             // nothing
         }
     }
     if (ret)
         return ret->tabBoxClient();
     else
         return QWeakPointer<TabBoxClient>();
 }
 
 TabBoxClientList TabBoxHandlerImpl::stackingOrder() const
 {
     QList<Toplevel *> stacking = Workspace::self()->stackingOrder();
     TabBoxClientList ret;
     foreach (Toplevel *toplevel, stacking) {
         if (auto client = qobject_cast<AbstractClient*>(toplevel)) {
             ret.append(client->tabBoxClient());
         }
     }
     return ret;
 }
 
 bool TabBoxHandlerImpl::isKWinCompositing() const {
     return Workspace::self()->compositing();
 }
 
 void TabBoxHandlerImpl::raiseClient(TabBoxClient* c) const
 {
     Workspace::self()->raiseClient(static_cast<TabBoxClientImpl*>(c)->client());
 }
 
 void TabBoxHandlerImpl::restack(TabBoxClient *c, TabBoxClient *under)
 {
     Workspace::self()->restack(static_cast<TabBoxClientImpl*>(c)->client(),
                                static_cast<TabBoxClientImpl*>(under)->client(), true);
 }
 
 void TabBoxHandlerImpl::elevateClient(TabBoxClient *c, QWindow *tabbox, bool b) const
 {
     auto cl = static_cast<TabBoxClientImpl*>(c)->client();
     cl->elevate(b);
     if (Toplevel *w = Workspace::self()->findInternal(tabbox))
         w->elevate(b);
 }
 
 void TabBoxHandlerImpl::shadeClient(TabBoxClient *c, bool b) const
 {
-    X11Client *cl = dynamic_cast<X11Client *>(static_cast<TabBoxClientImpl*>(c)->client());
-    if (!cl) {
-        // shading is X11 specific
-        return;
-    }
-    cl->cancelShadeHoverTimer(); // stop core shading action
-    if (!b && cl->shadeMode() == ShadeNormal)
-        cl->setShade(ShadeHover);
-    else if (b && cl->shadeMode() == ShadeHover)
-        cl->setShade(ShadeNormal);
+    AbstractClient *client = static_cast<TabBoxClientImpl *>(c)->client();
+    client->cancelShadeHoverTimer(); // stop core shading action
+    if (!b && client->shadeMode() == ShadeNormal)
+        client->setShade(ShadeHover);
+    else if (b && client->shadeMode() == ShadeHover)
+        client->setShade(ShadeNormal);
 }
 
 QWeakPointer<TabBoxClient> TabBoxHandlerImpl::desktopClient() const
 {
     foreach (Toplevel *toplevel, Workspace::self()->stackingOrder()) {
         auto client = qobject_cast<AbstractClient*>(toplevel);
         if (client && client->isDesktop() && client->isOnCurrentDesktop() && client->screen() == screens()->current()) {
             return client->tabBoxClient();
         }
     }
     return QWeakPointer<TabBoxClient>();
 }
 
 void TabBoxHandlerImpl::activateAndClose()
 {
     m_tabBox->accept();
 }
 
 void TabBoxHandlerImpl::highlightWindows(TabBoxClient *window, QWindow *controller)
 {
     if (!effects) {
         return;
     }
     QVector<EffectWindow*> windows;
     if (window) {
         windows << static_cast<TabBoxClientImpl*>(window)->client()->effectWindow();
     }
     if (Toplevel *t = workspace()->findInternal(controller)) {
         windows << t->effectWindow();
     }
     static_cast<EffectsHandlerImpl*>(effects)->highlightWindows(windows);
 }
 
 bool TabBoxHandlerImpl::noModifierGrab() const
 {
     return m_tabBox->noModifierGrab();
 }
 
 /*********************************************************
 * TabBoxClientImpl
 *********************************************************/
 
 TabBoxClientImpl::TabBoxClientImpl(AbstractClient *client)
     : TabBoxClient()
     , m_client(client)
 {
 }
 
 TabBoxClientImpl::~TabBoxClientImpl()
 {
 }
 
 QString TabBoxClientImpl::caption() const
 {
     if (m_client->isDesktop())
         return i18nc("Special entry in alt+tab list for minimizing all windows",
                      "Show Desktop");
     return m_client->caption();
 }
 
 QIcon TabBoxClientImpl::icon() const
 {
     if (m_client->isDesktop()) {
         return QIcon::fromTheme(QStringLiteral("user-desktop"));
     }
     return m_client->icon();
 }
 
 bool TabBoxClientImpl::isMinimized() const
 {
     return m_client->isMinimized();
 }
 
 int TabBoxClientImpl::x() const
 {
     return m_client->x();
 }
 
 int TabBoxClientImpl::y() const
 {
     return m_client->y();
 }
 
 int TabBoxClientImpl::width() const
 {
     return m_client->width();
 }
 
 int TabBoxClientImpl::height() const
 {
     return m_client->height();
 }
 
 bool TabBoxClientImpl::isCloseable() const
 {
     return m_client->isCloseable();
 }
 
 void TabBoxClientImpl::close()
 {
     m_client->closeWindow();
 }
 
 bool TabBoxClientImpl::isFirstInTabBox() const
 {
     return m_client->isFirstInTabBox();
 }
 
 QUuid TabBoxClientImpl::internalId() const
 {
     return m_client->internalId();
 }
 
 /*********************************************************
 * TabBox
 *********************************************************/
 TabBox *TabBox::s_self = nullptr;
 
 TabBox *TabBox::create(QObject *parent)
 {
     Q_ASSERT(!s_self);
     s_self = new TabBox(parent);
     return s_self;
 }
 
 TabBox::TabBox(QObject *parent)
     : QObject(parent)
     , m_displayRefcount(0)
     , m_desktopGrab(false)
     , m_tabGrab(false)
     , m_noModifierGrab(false)
     , m_forcedGlobalMouseGrab(false)
     , m_ready(false)
 {
     m_isShown = false;
     m_defaultConfig = TabBoxConfig();
     m_defaultConfig.setTabBoxMode(TabBoxConfig::ClientTabBox);
     m_defaultConfig.setClientDesktopMode(TabBoxConfig::OnlyCurrentDesktopClients);
     m_defaultConfig.setClientActivitiesMode(TabBoxConfig::OnlyCurrentActivityClients);
     m_defaultConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsAllApplications);
     m_defaultConfig.setClientMinimizedMode(TabBoxConfig::IgnoreMinimizedStatus);
     m_defaultConfig.setShowDesktopMode(TabBoxConfig::DoNotShowDesktopClient);
     m_defaultConfig.setClientMultiScreenMode(TabBoxConfig::IgnoreMultiScreen);
     m_defaultConfig.setClientSwitchingMode(TabBoxConfig::FocusChainSwitching);
 
     m_alternativeConfig = TabBoxConfig();
     m_alternativeConfig.setTabBoxMode(TabBoxConfig::ClientTabBox);
     m_alternativeConfig.setClientDesktopMode(TabBoxConfig::AllDesktopsClients);
     m_alternativeConfig.setClientActivitiesMode(TabBoxConfig::OnlyCurrentActivityClients);
     m_alternativeConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsAllApplications);
     m_alternativeConfig.setClientMinimizedMode(TabBoxConfig::IgnoreMinimizedStatus);
     m_alternativeConfig.setShowDesktopMode(TabBoxConfig::DoNotShowDesktopClient);
     m_alternativeConfig.setClientMultiScreenMode(TabBoxConfig::IgnoreMultiScreen);
     m_alternativeConfig.setClientSwitchingMode(TabBoxConfig::FocusChainSwitching);
 
     m_defaultCurrentApplicationConfig = m_defaultConfig;
     m_defaultCurrentApplicationConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsCurrentApplication);
 
     m_alternativeCurrentApplicationConfig = m_alternativeConfig;
     m_alternativeCurrentApplicationConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsCurrentApplication);
 
     m_desktopConfig = TabBoxConfig();
     m_desktopConfig.setTabBoxMode(TabBoxConfig::DesktopTabBox);
     m_desktopConfig.setShowTabBox(true);
     m_desktopConfig.setShowDesktopMode(TabBoxConfig::DoNotShowDesktopClient);
     m_desktopConfig.setDesktopSwitchingMode(TabBoxConfig::MostRecentlyUsedDesktopSwitching);
 
     m_desktopListConfig = TabBoxConfig();
     m_desktopListConfig.setTabBoxMode(TabBoxConfig::DesktopTabBox);
     m_desktopListConfig.setShowTabBox(true);
     m_desktopListConfig.setShowDesktopMode(TabBoxConfig::DoNotShowDesktopClient);
     m_desktopListConfig.setDesktopSwitchingMode(TabBoxConfig::StaticDesktopSwitching);
     m_tabBox = new TabBoxHandlerImpl(this);
     QTimer::singleShot(0, this, SLOT(handlerReady()));
 
     m_tabBoxMode = TabBoxDesktopMode; // init variables
     connect(&m_delayedShowTimer, SIGNAL(timeout()), this, SLOT(show()));
     connect(Workspace::self(), SIGNAL(configChanged()), this, SLOT(reconfigure()));
 }
 
 TabBox::~TabBox()
 {
     s_self = nullptr;
 }
 
 void TabBox::handlerReady()
 {
     m_tabBox->setConfig(m_defaultConfig);
     reconfigure();
     m_ready = true;
 }
 
 template <typename Slot>
 void TabBox::key(const char *actionName, Slot slot, const QKeySequence &shortcut)
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(QString::fromUtf8(actionName));
     a->setText(i18n(actionName));
     KGlobalAccel::self()->setGlobalShortcut(a, QList<QKeySequence>() << shortcut);
     input()->registerShortcut(shortcut, a, TabBox::self(), slot);
     auto cuts = KGlobalAccel::self()->shortcut(a);
     globalShortcutChanged(a, cuts.isEmpty() ? QKeySequence() : cuts.first());
 }
 
 static const char s_windows[]        = I18N_NOOP("Walk Through Windows");
 static const char s_windowsRev[]     = I18N_NOOP("Walk Through Windows (Reverse)");
 static const char s_windowsAlt[]     = I18N_NOOP("Walk Through Windows Alternative");
 static const char s_windowsAltRev[]  = I18N_NOOP("Walk Through Windows Alternative (Reverse)");
 static const char s_app[]            = I18N_NOOP("Walk Through Windows of Current Application");
 static const char s_appRev[]         = I18N_NOOP("Walk Through Windows of Current Application (Reverse)");
 static const char s_appAlt[]         = I18N_NOOP("Walk Through Windows of Current Application Alternative");
 static const char s_appAltRev[]      = I18N_NOOP("Walk Through Windows of Current Application Alternative (Reverse)");
 static const char s_desktops[]       = I18N_NOOP("Walk Through Desktops");
 static const char s_desktopsRev[]    = I18N_NOOP("Walk Through Desktops (Reverse)");
 static const char s_desktopList[]    = I18N_NOOP("Walk Through Desktop List");
 static const char s_desktopListRev[] = I18N_NOOP("Walk Through Desktop List (Reverse)");
 
 void TabBox::initShortcuts()
 {
     key(s_windows,        &TabBox::slotWalkThroughWindows, Qt::ALT + Qt::Key_Tab);
     key(s_windowsRev,     &TabBox::slotWalkBackThroughWindows, Qt::ALT + Qt::SHIFT + Qt::Key_Backtab);
     key(s_app,            &TabBox::slotWalkThroughCurrentAppWindows, Qt::ALT + Qt::Key_QuoteLeft);
     key(s_appRev,         &TabBox::slotWalkBackThroughCurrentAppWindows, Qt::ALT + Qt::Key_AsciiTilde);
     key(s_windowsAlt,     &TabBox::slotWalkThroughWindowsAlternative);
     key(s_windowsAltRev,  &TabBox::slotWalkBackThroughWindowsAlternative);
     key(s_appAlt,         &TabBox::slotWalkThroughCurrentAppWindowsAlternative);
     key(s_appAltRev,      &TabBox::slotWalkBackThroughCurrentAppWindowsAlternative);
     key(s_desktops,       &TabBox::slotWalkThroughDesktops);
     key(s_desktopsRev,    &TabBox::slotWalkBackThroughDesktops);
     key(s_desktopList,    &TabBox::slotWalkThroughDesktopList);
     key(s_desktopListRev, &TabBox::slotWalkBackThroughDesktopList);
 
     connect(KGlobalAccel::self(), &KGlobalAccel::globalShortcutChanged, this, &TabBox::globalShortcutChanged);
 }
 
 void TabBox::globalShortcutChanged(QAction *action, const QKeySequence &seq)
 {
     if (qstrcmp(qPrintable(action->objectName()), s_windows) == 0) {
         m_cutWalkThroughWindows = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_windowsRev) == 0) {
         m_cutWalkThroughWindowsReverse = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_app) == 0) {
         m_cutWalkThroughCurrentAppWindows = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_appRev) == 0) {
         m_cutWalkThroughCurrentAppWindowsReverse = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_windowsAlt) == 0) {
         m_cutWalkThroughWindowsAlternative = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_windowsAltRev) == 0) {
         m_cutWalkThroughWindowsAlternativeReverse = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_appAlt) == 0) {
         m_cutWalkThroughCurrentAppWindowsAlternative = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_appAltRev) == 0) {
         m_cutWalkThroughCurrentAppWindowsAlternativeReverse = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_desktops) == 0) {
         m_cutWalkThroughDesktops = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_desktopsRev) == 0) {
         m_cutWalkThroughDesktopsReverse = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_desktopList) == 0) {
         m_cutWalkThroughDesktopList = seq;
     } else if (qstrcmp(qPrintable(action->objectName()), s_desktopListRev) == 0) {
         m_cutWalkThroughDesktopListReverse = seq;
     }
 }
 
 void TabBox::setMode(TabBoxMode mode)
 {
     m_tabBoxMode = mode;
     switch(mode) {
     case TabBoxWindowsMode:
         m_tabBox->setConfig(m_defaultConfig);
         break;
     case TabBoxWindowsAlternativeMode:
         m_tabBox->setConfig(m_alternativeConfig);
         break;
     case TabBoxCurrentAppWindowsMode:
         m_tabBox->setConfig(m_defaultCurrentApplicationConfig);
         break;
     case TabBoxCurrentAppWindowsAlternativeMode:
         m_tabBox->setConfig(m_alternativeCurrentApplicationConfig);
         break;
     case TabBoxDesktopMode:
         m_tabBox->setConfig(m_desktopConfig);
         break;
     case TabBoxDesktopListMode:
         m_tabBox->setConfig(m_desktopListConfig);
         break;
     }
 }
 
 void TabBox::reset(bool partial_reset)
 {
     switch(m_tabBox->config().tabBoxMode()) {
     case TabBoxConfig::ClientTabBox:
         m_tabBox->createModel(partial_reset);
         if (!partial_reset) {
             if (Workspace::self()->activeClient())
                 setCurrentClient(Workspace::self()->activeClient());
             // it's possible that the active client is not part of the model
             // in that case the index is invalid
             if (!m_tabBox->currentIndex().isValid())
                 setCurrentIndex(m_tabBox->first());
         } else {
             if (!m_tabBox->currentIndex().isValid() || !m_tabBox->client(m_tabBox->currentIndex()))
                 setCurrentIndex(m_tabBox->first());
         }
         break;
     case TabBoxConfig::DesktopTabBox:
         m_tabBox->createModel();
 
         if (!partial_reset)
             setCurrentDesktop(VirtualDesktopManager::self()->current());
         break;
     }
 
     emit tabBoxUpdated();
 }
 
 void TabBox::nextPrev(bool next)
 {
     setCurrentIndex(m_tabBox->nextPrev(next), false);
     emit tabBoxUpdated();
 }
 
 AbstractClient* TabBox::currentClient()
 {
     if (TabBoxClientImpl* client = static_cast< TabBoxClientImpl* >(m_tabBox->client(m_tabBox->currentIndex()))) {
         if (!Workspace::self()->hasClient(client->client()))
             return nullptr;
         return client->client();
     } else
         return nullptr;
 }
 
 QList<AbstractClient*> TabBox::currentClientList()
 {
     TabBoxClientList list = m_tabBox->clientList();
     QList<AbstractClient*> ret;
     foreach (const QWeakPointer<TabBoxClient> &clientPointer, list) {
         QSharedPointer<TabBoxClient> client = clientPointer.toStrongRef();
         if (!client)
             continue;
         if (const TabBoxClientImpl* c = static_cast< const TabBoxClientImpl* >(client.data()))
             ret.append(c->client());
     }
     return ret;
 }
 
 int TabBox::currentDesktop()
 {
     return m_tabBox->desktop(m_tabBox->currentIndex());
 }
 
 QList< int > TabBox::currentDesktopList()
 {
     return m_tabBox->desktopList();
 }
 
 void TabBox::setCurrentClient(AbstractClient *newClient)
 {
     setCurrentIndex(m_tabBox->index(newClient->tabBoxClient()));
 }
 
 void TabBox::setCurrentDesktop(int newDesktop)
 {
     setCurrentIndex(m_tabBox->desktopIndex(newDesktop));
 }
 
 void TabBox::setCurrentIndex(QModelIndex index, bool notifyEffects)
 {
     if (!index.isValid())
         return;
     m_tabBox->setCurrentIndex(index);
     if (notifyEffects) {
         emit tabBoxUpdated();
     }
 }
 
 void TabBox::show()
 {
     emit tabBoxAdded(m_tabBoxMode);
     if (isDisplayed()) {
         m_isShown = false;
         return;
     }
     workspace()->setShowingDesktop(false);
     reference();
     m_isShown = true;
     m_tabBox->show();
 }
 
 void TabBox::hide(bool abort)
 {
     m_delayedShowTimer.stop();
     if (m_isShown) {
         m_isShown = false;
         unreference();
     }
     emit tabBoxClosed();
     if (isDisplayed())
         qCDebug(KWIN_TABBOX) << "Tab box was not properly closed by an effect";
     m_tabBox->hide(abort);
     if (kwinApp()->x11Connection()) {
         Xcb::sync();
     }
 }
 
 void TabBox::reconfigure()
 {
     KSharedConfigPtr c = kwinApp()->config();
     KConfigGroup config = c->group("TabBox");
 
     loadConfig(c->group("TabBox"), m_defaultConfig);
     loadConfig(c->group("TabBoxAlternative"), m_alternativeConfig);
 
     m_defaultCurrentApplicationConfig = m_defaultConfig;
     m_defaultCurrentApplicationConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsCurrentApplication);
     m_alternativeCurrentApplicationConfig = m_alternativeConfig;
     m_alternativeCurrentApplicationConfig.setClientApplicationsMode(TabBoxConfig::AllWindowsCurrentApplication);
 
     m_tabBox->setConfig(m_defaultConfig);
 
     m_delayShow = config.readEntry<bool>("ShowDelay", true);
     m_delayShowTime = config.readEntry<int>("DelayTime", 90);
 
     const QString defaultDesktopLayout = QStringLiteral("org.kde.breeze.desktop");
     m_desktopConfig.setLayoutName(config.readEntry("DesktopLayout", defaultDesktopLayout));
     m_desktopListConfig.setLayoutName(config.readEntry("DesktopListLayout", defaultDesktopLayout));
 
     QList<ElectricBorder> *borders = &m_borderActivate;
     QString borderConfig = QStringLiteral("BorderActivate");
     for (int i = 0; i < 2; ++i) {
         foreach (ElectricBorder border, *borders) {
             ScreenEdges::self()->unreserve(border, this);
         }
         borders->clear();
         QStringList list = config.readEntry(borderConfig, QStringList());
         foreach (const QString &s, list) {
             bool ok;
             const int i = s.toInt(&ok);
             if (!ok)
                 continue;
             borders->append(ElectricBorder(i));
             ScreenEdges::self()->reserve(ElectricBorder(i), this, "toggle");
         }
         borders = &m_borderAlternativeActivate;
         borderConfig = QStringLiteral("BorderAlternativeActivate");
     }
 
     auto touchConfig = [this, config] (const QString &key, QHash<ElectricBorder, QAction *> &actions, TabBoxMode mode, const QStringList &defaults = QStringList{}) {
         // fist erase old config
         for (auto it = actions.begin(); it != actions.end(); ) {
             delete it.value();
             it = actions.erase(it);
         }
         // now new config
         const QStringList list = config.readEntry(key, defaults);
         for (const auto &s : list) {
             bool ok;
             const int i = s.toInt(&ok);
             if (!ok) {
                 continue;
             }
             QAction *a = new QAction(this);
             connect(a, &QAction::triggered, this, std::bind(&TabBox::toggleMode, this, mode));
             ScreenEdges::self()->reserveTouch(ElectricBorder(i), a);
             actions.insert(ElectricBorder(i), a);
         }
     };
     touchConfig(QStringLiteral("TouchBorderActivate"), m_touchActivate, TabBoxWindowsMode, QStringList{QString::number(int(ElectricLeft))});
     touchConfig(QStringLiteral("TouchBorderAlternativeActivate"), m_touchAlternativeActivate, TabBoxWindowsAlternativeMode);
 }
 
 void TabBox::loadConfig(const KConfigGroup& config, TabBoxConfig& tabBoxConfig)
 {
     tabBoxConfig.setClientDesktopMode(TabBoxConfig::ClientDesktopMode(
                                        config.readEntry<int>("DesktopMode", TabBoxConfig::defaultDesktopMode())));
     tabBoxConfig.setClientActivitiesMode(TabBoxConfig::ClientActivitiesMode(
                                        config.readEntry<int>("ActivitiesMode", TabBoxConfig::defaultActivitiesMode())));
     tabBoxConfig.setClientApplicationsMode(TabBoxConfig::ClientApplicationsMode(
                                        config.readEntry<int>("ApplicationsMode", TabBoxConfig::defaultApplicationsMode())));
     tabBoxConfig.setClientMinimizedMode(TabBoxConfig::ClientMinimizedMode(
                                        config.readEntry<int>("MinimizedMode", TabBoxConfig::defaultMinimizedMode())));
     tabBoxConfig.setShowDesktopMode(TabBoxConfig::ShowDesktopMode(
                                        config.readEntry<int>("ShowDesktopMode", TabBoxConfig::defaultShowDesktopMode())));
     tabBoxConfig.setClientMultiScreenMode(TabBoxConfig::ClientMultiScreenMode(
                                        config.readEntry<int>("MultiScreenMode", TabBoxConfig::defaultMultiScreenMode())));
     tabBoxConfig.setClientSwitchingMode(TabBoxConfig::ClientSwitchingMode(
                                             config.readEntry<int>("SwitchingMode", TabBoxConfig::defaultSwitchingMode())));
 
     tabBoxConfig.setShowTabBox(config.readEntry<bool>("ShowTabBox",
                                TabBoxConfig::defaultShowTabBox()));
     tabBoxConfig.setHighlightWindows(config.readEntry<bool>("HighlightWindows",
                                      TabBoxConfig::defaultHighlightWindow()));
 
     tabBoxConfig.setLayoutName(config.readEntry<QString>("LayoutName", TabBoxConfig::defaultLayoutName()));
 }
 
 void TabBox::delayedShow()
 {
     if (isDisplayed() || m_delayedShowTimer.isActive())
         // already called show - no need to call it twice
         return;
 
     if (!m_delayShowTime) {
         show();
         return;
     }
 
     m_delayedShowTimer.setSingleShot(true);
     m_delayedShowTimer.start(m_delayShowTime);
 }
 
 bool TabBox::handleMouseEvent(QMouseEvent *event)
 {
     if (!m_isShown && isDisplayed()) {
         // tabbox has been replaced, check effects
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event)) {
             return true;
         }
     }
     switch (event->type()) {
     case QEvent::MouseMove:
         if (!m_tabBox->containsPos(event->globalPos())) {
             // filter out all events which are not on the TabBox window.
             // We don't want windows to react on the mouse events
             return true;
         }
         return false;
     case QEvent::MouseButtonPress:
         if ((!m_isShown && isDisplayed()) || !m_tabBox->containsPos(event->globalPos())) {
             close();  // click outside closes tab
             return true;
         }
         // fall through
     case QEvent::MouseButtonRelease:
     default:
         // we do not filter it out, the intenal filter takes care
         return false;
     }
     return false;
 }
 
 bool TabBox::handleWheelEvent(QWheelEvent *event)
 {
     if (!m_isShown && isDisplayed()) {
         // tabbox has been replaced, check effects
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event)) {
             return true;
         }
     }
     if (event->angleDelta().y() == 0) {
         return false;
     }
     const QModelIndex index = m_tabBox->nextPrev(event->angleDelta().y() > 0);
     if (index.isValid()) {
         setCurrentIndex(index);
     }
     return true;
 }
 
 void TabBox::grabbedKeyEvent(QKeyEvent* event)
 {
     emit tabBoxKeyEvent(event);
     if (!m_isShown && isDisplayed()) {
         // tabbox has been replaced, check effects
         return;
     }
     if (m_noModifierGrab) {
         if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return || event->key() == Qt::Key_Space) {
             accept();
             return;
         }
     }
     m_tabBox->grabbedKeyEvent(event);
 }
 
 struct KeySymbolsDeleter
 {
     static inline void cleanup(xcb_key_symbols_t *symbols)
     {
         xcb_key_symbols_free(symbols);
     }
 };
 
 /**
  * Handles alt-tab / control-tab
  */
 static bool areKeySymXsDepressed(const uint keySyms[], int nKeySyms)
 {
     Xcb::QueryKeymap keys;
 
     QScopedPointer<xcb_key_symbols_t, KeySymbolsDeleter> symbols(xcb_key_symbols_alloc(connection()));
     if (symbols.isNull() || !keys) {
         return false;
     }
     const auto keymap = keys->keys;
 
     bool depressed = false;
     for (int iKeySym = 0; iKeySym < nKeySyms; iKeySym++) {
         uint keySymX = keySyms[ iKeySym ];
         xcb_keycode_t *keyCodes = xcb_key_symbols_get_keycode(symbols.data(), keySymX);
         if (!keyCodes) {
             continue;
         }
 
         int j = 0;
         while (keyCodes[j] != XCB_NO_SYMBOL) {
             const xcb_keycode_t keyCodeX = keyCodes[j++];
             int i = keyCodeX / 8;
             char mask = 1 << (keyCodeX - (i * 8));
 
             if (i < 0 || i >= 32) {
                 continue;
             }
 
             qCDebug(KWIN_TABBOX)    << iKeySym << ": keySymX=0x" << QString::number(keySymX, 16)
                         << " i=" << i << " mask=0x" << QString::number(mask, 16)
                         << " keymap[i]=0x" << QString::number(keymap[i], 16);
 
             if (keymap[i] & mask) {
                 depressed = true;
                 break;
             }
         }
 
         free(keyCodes);
     }
 
     return depressed;
 }
 
 static bool areModKeysDepressedX11(const QKeySequence &seq)
 {
     uint rgKeySyms[10];
     int nKeySyms = 0;
     int mod = seq[seq.count()-1] & Qt::KeyboardModifierMask;
 
     if (mod & Qt::SHIFT) {
         rgKeySyms[nKeySyms++] = XK_Shift_L;
         rgKeySyms[nKeySyms++] = XK_Shift_R;
     }
     if (mod & Qt::CTRL) {
         rgKeySyms[nKeySyms++] = XK_Control_L;
         rgKeySyms[nKeySyms++] = XK_Control_R;
     }
     if (mod & Qt::ALT) {
         rgKeySyms[nKeySyms++] = XK_Alt_L;
         rgKeySyms[nKeySyms++] = XK_Alt_R;
     }
     if (mod & Qt::META) {
         // It would take some code to determine whether the Win key
         // is associated with Super or Meta, so check for both.
         // See bug #140023 for details.
         rgKeySyms[nKeySyms++] = XK_Super_L;
         rgKeySyms[nKeySyms++] = XK_Super_R;
         rgKeySyms[nKeySyms++] = XK_Meta_L;
         rgKeySyms[nKeySyms++] = XK_Meta_R;
     }
 
     return areKeySymXsDepressed(rgKeySyms, nKeySyms);
 }
 
 static bool areModKeysDepressedWayland(const QKeySequence &seq)
 {
     const int mod = seq[seq.count()-1] & Qt::KeyboardModifierMask;
     const Qt::KeyboardModifiers mods = input()->modifiersRelevantForGlobalShortcuts();
     if ((mod & Qt::SHIFT) && mods.testFlag(Qt::ShiftModifier)) {
         return true;
     }
     if ((mod & Qt::CTRL) && mods.testFlag(Qt::ControlModifier)) {
         return true;
     }
     if ((mod & Qt::ALT) && mods.testFlag(Qt::AltModifier)) {
         return true;
     }
     if ((mod & Qt::META) && mods.testFlag(Qt::MetaModifier)) {
         return true;
     }
     return false;
 }
 
 static bool areModKeysDepressed(const QKeySequence& seq) {
     if (seq.isEmpty())
         return false;
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         return areModKeysDepressedWayland(seq);
     } else {
         return areModKeysDepressedX11(seq);
     }
 }
 
 void TabBox::navigatingThroughWindows(bool forward, const QKeySequence &shortcut, TabBoxMode mode)
 {
     if (!m_ready || isGrabbed() || !Workspace::self()->isOnCurrentHead()) {
         return;
     }
     if (!options->focusPolicyIsReasonable()) {
         //ungrabXKeyboard(); // need that because of accelerator raw mode
         // CDE style raise / lower
         CDEWalkThroughWindows(forward);
     } else {
         if (areModKeysDepressed(shortcut)) {
             if (startKDEWalkThroughWindows(mode))
                 KDEWalkThroughWindows(forward);
         } else
             // if the shortcut has no modifiers, don't show the tabbox,
             // don't grab, but simply go to the next window
             KDEOneStepThroughWindows(forward, mode);
     }
 }
 
 void TabBox::slotWalkThroughWindows()
 {
     navigatingThroughWindows(true, m_cutWalkThroughWindows, TabBoxWindowsMode);
 }
 
 void TabBox::slotWalkBackThroughWindows()
 {
     navigatingThroughWindows(false, m_cutWalkThroughWindowsReverse, TabBoxWindowsMode);
 }
 
 void TabBox::slotWalkThroughWindowsAlternative()
 {
     navigatingThroughWindows(true, m_cutWalkThroughWindowsAlternative, TabBoxWindowsAlternativeMode);
 }
 
 void TabBox::slotWalkBackThroughWindowsAlternative()
 {
     navigatingThroughWindows(false, m_cutWalkThroughWindowsAlternativeReverse, TabBoxWindowsAlternativeMode);
 }
 
 void TabBox::slotWalkThroughCurrentAppWindows()
 {
     navigatingThroughWindows(true, m_cutWalkThroughCurrentAppWindows, TabBoxCurrentAppWindowsMode);
 }
 
 void TabBox::slotWalkBackThroughCurrentAppWindows()
 {
     navigatingThroughWindows(false, m_cutWalkThroughCurrentAppWindowsReverse, TabBoxCurrentAppWindowsMode);
 }
 
 void TabBox::slotWalkThroughCurrentAppWindowsAlternative()
 {
     navigatingThroughWindows(true, m_cutWalkThroughCurrentAppWindowsAlternative, TabBoxCurrentAppWindowsAlternativeMode);
 }
 
 void TabBox::slotWalkBackThroughCurrentAppWindowsAlternative()
 {
     navigatingThroughWindows(false, m_cutWalkThroughCurrentAppWindowsAlternativeReverse, TabBoxCurrentAppWindowsAlternativeMode);
 }
 
 void TabBox::slotWalkThroughDesktops()
 {
     if (!m_ready || isGrabbed() || !Workspace::self()->isOnCurrentHead()) {
         return;
     }
     if (areModKeysDepressed(m_cutWalkThroughDesktops)) {
         if (startWalkThroughDesktops())
             walkThroughDesktops(true);
     } else {
         oneStepThroughDesktops(true);
     }
 }
 
 void TabBox::slotWalkBackThroughDesktops()
 {
     if (!m_ready || isGrabbed() || !Workspace::self()->isOnCurrentHead()) {
         return;
     }
     if (areModKeysDepressed(m_cutWalkThroughDesktopsReverse)) {
         if (startWalkThroughDesktops())
             walkThroughDesktops(false);
     } else {
         oneStepThroughDesktops(false);
     }
 }
 
 void TabBox::slotWalkThroughDesktopList()
 {
     if (!m_ready || isGrabbed() || !Workspace::self()->isOnCurrentHead()) {
         return;
     }
     if (areModKeysDepressed(m_cutWalkThroughDesktopList)) {
         if (startWalkThroughDesktopList())
             walkThroughDesktops(true);
     } else {
         oneStepThroughDesktopList(true);
     }
 }
 
 void TabBox::slotWalkBackThroughDesktopList()
 {
     if (!m_ready || isGrabbed() || !Workspace::self()->isOnCurrentHead()) {
         return;
     }
     if (areModKeysDepressed(m_cutWalkThroughDesktopListReverse)) {
         if (startWalkThroughDesktopList())
             walkThroughDesktops(false);
     } else {
         oneStepThroughDesktopList(false);
     }
 }
 
 void TabBox::shadeActivate(AbstractClient *c)
 {
     if ((c->shadeMode() == ShadeNormal || c->shadeMode() == ShadeHover) && options->isShadeHover())
         c->setShade(ShadeActivated);
 }
 
 bool TabBox::toggle(ElectricBorder eb)
 {
     if (m_borderAlternativeActivate.contains(eb)) {
         return toggleMode(TabBoxWindowsAlternativeMode);
     } else {
         return toggleMode(TabBoxWindowsMode);
     }
 }
 
 bool TabBox::toggleMode(TabBoxMode mode)
 {
     if (!options->focusPolicyIsReasonable())
         return false; // not supported.
     if (isDisplayed()) {
         accept();
         return true;
     }
     if (!establishTabBoxGrab())
         return false;
     m_noModifierGrab = m_tabGrab = true;
     setMode(mode);
     reset();
     show();
     return true;
 }
 
 bool TabBox::startKDEWalkThroughWindows(TabBoxMode mode)
 {
     if (!establishTabBoxGrab())
         return false;
     m_tabGrab = true;
     m_noModifierGrab = false;
     setMode(mode);
     reset();
     return true;
 }
 
 bool TabBox::startWalkThroughDesktops(TabBoxMode mode)
 {
     if (!establishTabBoxGrab())
         return false;
     m_desktopGrab = true;
     m_noModifierGrab = false;
     setMode(mode);
     reset();
     return true;
 }
 
 bool TabBox::startWalkThroughDesktops()
 {
     return startWalkThroughDesktops(TabBoxDesktopMode);
 }
 
 bool TabBox::startWalkThroughDesktopList()
 {
     return startWalkThroughDesktops(TabBoxDesktopListMode);
 }
 
 void TabBox::KDEWalkThroughWindows(bool forward)
 {
     nextPrev(forward);
     delayedShow();
 }
 
 void TabBox::walkThroughDesktops(bool forward)
 {
     nextPrev(forward);
     delayedShow();
 }
 
 void TabBox::CDEWalkThroughWindows(bool forward)
 {
     AbstractClient* c = nullptr;
 // this function find the first suitable client for unreasonable focus
 // policies - the topmost one, with some exceptions (can't be keepabove/below,
 // otherwise it gets stuck on them)
 //     Q_ASSERT(Workspace::self()->block_stacking_updates == 0);
     for (int i = Workspace::self()->stackingOrder().size() - 1;
             i >= 0 ;
             --i) {
         auto it = qobject_cast<AbstractClient*>(Workspace::self()->stackingOrder().at(i));
         if (it && it->isOnCurrentActivity() && it->isOnCurrentDesktop() && !it->isSpecialWindow()
                 && it->isShown(false) && it->wantsTabFocus()
                 && !it->keepAbove() && !it->keepBelow()) {
             c = it;
             break;
         }
     }
     AbstractClient* nc = c;
     bool options_traverse_all;
     {
         KConfigGroup group(kwinApp()->config(), "TabBox");
         options_traverse_all = group.readEntry("TraverseAll", false);
     }
 
     AbstractClient* firstClient = nullptr;
     do {
         nc = forward ? nextClientStatic(nc) : previousClientStatic(nc);
         if (!firstClient) {
             // When we see our first client for the second time,
             // it's time to stop.
             firstClient = nc;
         } else if (nc == firstClient) {
             // No candidates found.
             nc = nullptr;
             break;
         }
     } while (nc && nc != c &&
             ((!options_traverse_all && !nc->isOnDesktop(currentDesktop())) ||
              nc->isMinimized() || !nc->wantsTabFocus() || nc->keepAbove() || nc->keepBelow() || !nc->isOnCurrentActivity()));
     if (nc) {
         if (c && c != nc)
             Workspace::self()->lowerClient(c);
         if (options->focusPolicyIsReasonable()) {
             Workspace::self()->activateClient(nc);
             shadeActivate(nc);
         } else {
             if (!nc->isOnDesktop(currentDesktop()))
                 setCurrentDesktop(nc->desktop());
             Workspace::self()->raiseClient(nc);
         }
     }
 }
 
 void TabBox::KDEOneStepThroughWindows(bool forward, TabBoxMode mode)
 {
     setMode(mode);
     reset();
     nextPrev(forward);
     if (AbstractClient* c = currentClient()) {
         Workspace::self()->activateClient(c);
         shadeActivate(c);
     }
 }
 
 void TabBox::oneStepThroughDesktops(bool forward, TabBoxMode mode)
 {
     setMode(mode);
     reset();
     nextPrev(forward);
     if (currentDesktop() != -1)
         setCurrentDesktop(currentDesktop());
 }
 
 void TabBox::oneStepThroughDesktops(bool forward)
 {
     oneStepThroughDesktops(forward, TabBoxDesktopMode);
 }
 
 void TabBox::oneStepThroughDesktopList(bool forward)
 {
     oneStepThroughDesktops(forward, TabBoxDesktopListMode);
 }
 
 void TabBox::keyPress(int keyQt)
 {
     enum Direction { Backward = -1, Steady = 0, Forward = 1 };
     Direction direction(Steady);
 
     auto contains = [](const QKeySequence &shortcut, int key) -> bool {
         for (int i = 0; i < shortcut.count(); ++i) {
             if (shortcut[i] == key) {
                 return true;
             }
         }
         return false;
     };
 
     // tests whether a shortcut matches and handles pitfalls on ShiftKey invocation
     auto directionFor = [keyQt, contains](const QKeySequence &forward, const QKeySequence &backward) -> Direction {
         if (contains(forward, keyQt))
             return Forward;
         if (contains(backward, keyQt))
             return Backward;
         if (!(keyQt & Qt::ShiftModifier))
             return Steady;
 
         // Before testing the unshifted key (Ctrl+A vs. Ctrl+Shift+a etc.), see whether this is +Shift+Tab
         // and check that against +Shift+Backtab (as well)
         Qt::KeyboardModifiers mods = Qt::ShiftModifier|Qt::ControlModifier|Qt::AltModifier|Qt::MetaModifier|Qt::KeypadModifier|Qt::GroupSwitchModifier;
         mods &= keyQt;
         if ((keyQt & ~mods) == Qt::Key_Tab) {
             if (contains(forward, mods | Qt::Key_Backtab))
                 return Forward;
             if (contains(backward, mods | Qt::Key_Backtab))
                 return Backward;
         }
 
         // if the shortcuts do not match, try matching again after filtering the shift key from keyQt
         // it is needed to handle correctly the ALT+~ shorcut for example as it is coded as ALT+SHIFT+~ in keyQt
         if (contains(forward, keyQt & ~Qt::ShiftModifier))
             return Forward;
         if (contains(backward, keyQt & ~Qt::ShiftModifier))
             return Backward;
 
         return Steady;
     };
 
     if (m_tabGrab) {
         static const int ModeCount = 4;
         static const TabBoxMode modes[ModeCount] = {
             TabBoxWindowsMode, TabBoxWindowsAlternativeMode,
             TabBoxCurrentAppWindowsMode, TabBoxCurrentAppWindowsAlternativeMode
         };
         static const QKeySequence cuts[2*ModeCount] = {
             // forward
             m_cutWalkThroughWindows, m_cutWalkThroughWindowsAlternative,
             m_cutWalkThroughCurrentAppWindows, m_cutWalkThroughCurrentAppWindowsAlternative,
             // backward
             m_cutWalkThroughWindowsReverse, m_cutWalkThroughWindowsAlternativeReverse,
             m_cutWalkThroughCurrentAppWindowsReverse, m_cutWalkThroughCurrentAppWindowsAlternativeReverse
         };
         bool testedCurrent = false; // in case of collision, prefer to stay in the current mode
         int i = 0, j = 0;
         while (true) {
             if (!testedCurrent && modes[i] != mode()) {
                 ++j;
                 i = (i+1) % ModeCount;
                 continue;
             }
             if (testedCurrent && modes[i] == mode()) {
                 break;
             }
             testedCurrent = true;
             direction = directionFor(cuts[i], cuts[i+ModeCount]);
             if (direction != Steady) {
                 if (modes[i] != mode()) {
                     accept(false);
                     setMode(modes[i]);
                     auto replayWithChangedTabboxMode = [this, direction]() {
                         reset();
                         nextPrev(direction == Forward);
                     };
                     QTimer::singleShot(50, this, replayWithChangedTabboxMode);
                 }
                 break;
             } else if (++j > ModeCount) { // guarding counter for invalid modes
                 qCDebug(KWIN_TABBOX) << "Invalid TabBoxMode";
                 return;
             }
             i = (i+1) % ModeCount;
         }
         if (direction != Steady) {
             qCDebug(KWIN_TABBOX) << "== " << cuts[i].toString() << " or " << cuts[i+ModeCount].toString();
             KDEWalkThroughWindows(direction == Forward);
         }
     } else if (m_desktopGrab) {
         direction = directionFor(m_cutWalkThroughDesktops, m_cutWalkThroughDesktopsReverse);
         if (direction == Steady)
             direction = directionFor(m_cutWalkThroughDesktopList, m_cutWalkThroughDesktopListReverse);
         if (direction != Steady)
             walkThroughDesktops(direction == Forward);
     }
 
     if (m_desktopGrab || m_tabGrab) {
         if (((keyQt & ~Qt::KeyboardModifierMask) == Qt::Key_Escape) && direction == Steady) {
             // if Escape is part of the shortcut, don't cancel
             close(true);
         } else if (direction == Steady) {
             QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, keyQt & ~Qt::KeyboardModifierMask, Qt::NoModifier);
             grabbedKeyEvent(event);
         }
     }
 }
 
 void TabBox::close(bool abort)
 {
     if (isGrabbed()) {
         removeTabBoxGrab();
     }
     hide(abort);
     input()->pointer()->setEnableConstraints(true);
     m_tabGrab = false;
     m_desktopGrab = false;
     m_noModifierGrab = false;
 }
 
 void TabBox::accept(bool closeTabBox)
 {
     AbstractClient *c = currentClient();
     if (closeTabBox)
         close();
     if (c) {
         Workspace::self()->activateClient(c);
         shadeActivate(c);
         if (c->isDesktop())
             Workspace::self()->setShowingDesktop(!Workspace::self()->showingDesktop());
     }
 }
 
 void TabBox::modifiersReleased()
 {
     if (m_noModifierGrab) {
         return;
     }
     if (m_tabGrab) {
         bool old_control_grab = m_desktopGrab;
         accept();
         m_desktopGrab = old_control_grab;
     }
     if (m_desktopGrab) {
         bool old_tab_grab = m_tabGrab;
         int desktop = currentDesktop();
         close();
         m_tabGrab = old_tab_grab;
         if (desktop != -1) {
             setCurrentDesktop(desktop);
             VirtualDesktopManager::self()->setCurrent(desktop);
         }
     }
 }
 
 int TabBox::nextDesktopStatic(int iDesktop) const
 {
     DesktopNext functor;
     return functor(iDesktop, true);
 }
 
 int TabBox::previousDesktopStatic(int iDesktop) const
 {
     DesktopPrevious functor;
     return functor(iDesktop, true);
 }
 
 /**
  * Auxiliary functions to travers all clients according to the static
  * order. Useful for the CDE-style Alt-tab feature.
  */
 AbstractClient* TabBox::nextClientStatic(AbstractClient* c) const
 {
     const auto &list = Workspace::self()->allClientList();
     if (!c || list.isEmpty())
         return nullptr;
     int pos = list.indexOf(c);
     if (pos == -1)
         return list.first();
     ++pos;
     if (pos == list.count())
         return list.first();
     return list.at(pos);
 }
 
 /**
  * Auxiliary functions to travers all clients according to the static
  * order. Useful for the CDE-style Alt-tab feature.
  */
 AbstractClient* TabBox::previousClientStatic(AbstractClient* c) const
 {
     const auto &list = Workspace::self()->allClientList();
     if (!c || list.isEmpty())
         return nullptr;
     int pos = list.indexOf(c);
     if (pos == -1)
         return list.last();
     if (pos == 0)
         return list.last();
     --pos;
     return list.at(pos);
 }
 
 bool TabBox::establishTabBoxGrab()
 {
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         m_forcedGlobalMouseGrab = true;
         return true;
     }
     updateXTime();
     if (!grabXKeyboard())
         return false;
     // Don't try to establish a global mouse grab using XGrabPointer, as that would prevent
     // using Alt+Tab while DND (#44972). However force passive grabs on all windows
     // in order to catch MouseRelease events and close the tabbox (#67416).
     // All clients already have passive grabs in their wrapper windows, so check only
     // the active client, which may not have it.
     Q_ASSERT(!m_forcedGlobalMouseGrab);
     m_forcedGlobalMouseGrab = true;
     if (Workspace::self()->activeClient() != nullptr)
         Workspace::self()->activeClient()->updateMouseGrab();
     m_x11EventFilter.reset(new X11Filter);
     return true;
 }
 
 void TabBox::removeTabBoxGrab()
 {
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         m_forcedGlobalMouseGrab = false;
         return;
     }
     updateXTime();
     ungrabXKeyboard();
     Q_ASSERT(m_forcedGlobalMouseGrab);
     m_forcedGlobalMouseGrab = false;
     if (Workspace::self()->activeClient() != nullptr)
         Workspace::self()->activeClient()->updateMouseGrab();
     m_x11EventFilter.reset();
 }
 } // namespace TabBox
 } // namespace
 
diff --git a/useractions.cpp b/useractions.cpp
index 9f4386fbb..08e981128 100644
--- a/useractions.cpp
+++ b/useractions.cpp
@@ -1,1722 +1,1697 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
 
  This file contains things relevant to direct user actions, such as
  responses to global keyboard shortcuts, or selecting actions
  from the window operations menu.
 
 */
 
 ///////////////////////////////////////////////////////////////////////////////
 // NOTE: if you change the menu, keep
 //       plasma-desktop/applets/taskmanager/package/contents/ui/ContextMenu.qml
 //       in sync
 //////////////////////////////////////////////////////////////////////////////
 
 #include "useractions.h"
 #include "cursor.h"
 #include "x11client.h"
 #include "colorcorrection/manager.h"
 #include "composite.h"
 #include "input.h"
 #include "workspace.h"
 #include "effects.h"
 #include "platform.h"
 #include "screens.h"
 #include "virtualdesktops.h"
 #include "scripting/scripting.h"
 
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #include <kactivities/info.h>
 #endif
 #include "appmenu.h"
 
 #include <KProcess>
 
 #include <QAction>
 #include <QCheckBox>
 #include <QtConcurrentRun>
 #include <QPointer>
 #include <QPushButton>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <kconfig.h>
 #include <QRegExp>
 #include <QMenu>
 #include <QWidgetAction>
 #include <kauthorized.h>
 
 #include "killwindow.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 
 namespace KWin
 {
 
 UserActionsMenu::UserActionsMenu(QObject *parent)
     : QObject(parent)
     , m_menu(nullptr)
     , m_desktopMenu(nullptr)
     , m_screenMenu(nullptr)
     , m_activityMenu(nullptr)
     , m_scriptsMenu(nullptr)
     , m_resizeOperation(nullptr)
     , m_moveOperation(nullptr)
     , m_maximizeOperation(nullptr)
     , m_shadeOperation(nullptr)
     , m_keepAboveOperation(nullptr)
     , m_keepBelowOperation(nullptr)
     , m_fullScreenOperation(nullptr)
     , m_noBorderOperation(nullptr)
     , m_minimizeOperation(nullptr)
     , m_closeOperation(nullptr)
 {
 }
 
 UserActionsMenu::~UserActionsMenu()
 {
     discard();
 }
 
 bool UserActionsMenu::isShown() const
 {
     return m_menu && m_menu->isVisible();
 }
 
 bool UserActionsMenu::hasClient() const
 {
     return m_client && isShown();
 }
 
 void UserActionsMenu::close()
 {
     if (!m_menu) {
         return;
     }
     m_menu->close();
     m_client.clear();
 }
 
 bool UserActionsMenu::isMenuClient(const AbstractClient *c) const
 {
     return c && c == m_client;
 }
 
 void UserActionsMenu::show(const QRect &pos, AbstractClient *client)
 {
     Q_ASSERT(client);
     QPointer<AbstractClient> cl(client);
     // Presumably client will never be nullptr,
     // but play it safe and make sure not to crash.
     if (cl.isNull()) {
         return;
     }
     if (isShown()) {  // recursion
         return;
     }
     if (cl->isDesktop() || cl->isDock()) {
         return;
     }
     if (!KAuthorized::authorizeAction(QStringLiteral("kwin_rmb"))) {
         return;
     }
     m_client = cl;
     init();
     m_client->blockActivityUpdates(true);
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         m_menu->popup(pos.bottomLeft());
     } else {
         m_menu->exec(pos.bottomLeft());
     }
     if (m_client) {
         m_client->blockActivityUpdates(false);
     }
 }
 
 void UserActionsMenu::grabInput()
 {
     m_menu->windowHandle()->setMouseGrabEnabled(true);
     m_menu->windowHandle()->setKeyboardGrabEnabled(true);
 }
 
 void UserActionsMenu::helperDialog(const QString& message, AbstractClient* client)
 {
     QStringList args;
     QString type;
     auto shortcut = [](const QString &name) {
         QAction* action = Workspace::self()->findChild<QAction*>(name);
         Q_ASSERT(action != nullptr);
         const auto shortcuts = KGlobalAccel::self()->shortcut(action);
         return QStringLiteral("%1 (%2)").arg(action->text())
                              .arg(shortcuts.isEmpty() ? QString() : shortcuts.first().toString(QKeySequence::NativeText));
     };
     if (message == QStringLiteral("noborderaltf3")) {
         args << QStringLiteral("--msgbox") << i18n(
                  "You have selected to show a window without its border.\n"
                  "Without the border, you will not be able to enable the border "
                  "again using the mouse: use the window operations menu instead, "
                  "activated using the %1 keyboard shortcut.",
                  shortcut(QStringLiteral("Window Operations Menu")));
         type = QStringLiteral("altf3warning");
     } else if (message == QLatin1String("fullscreenaltf3")) {
         args << QStringLiteral("--msgbox") << i18n(
                  "You have selected to show a window in fullscreen mode.\n"
                  "If the application itself does not have an option to turn the fullscreen "
                  "mode off you will not be able to disable it "
                  "again using the mouse: use the window operations menu instead, "
                  "activated using the %1 keyboard shortcut.",
                  shortcut(QStringLiteral("Window Operations Menu")));
         type = QStringLiteral("altf3warning");
     } else
         abort();
     if (!type.isEmpty()) {
         KConfig cfg(QStringLiteral("kwin_dialogsrc"));
         KConfigGroup cg(&cfg, "Notification Messages");  // Depends on KMessageBox
         if (!cg.readEntry(type, true))
             return;
         args << QStringLiteral("--dontagain") << QLatin1String("kwin_dialogsrc:") + type;
     }
     if (client)
         args << QStringLiteral("--embed") << QString::number(client->windowId());
     QtConcurrent::run([args]() {
         KProcess::startDetached(QStringLiteral("kdialog"), args);
     });
 }
 
 
 QStringList configModules(bool controlCenter)
 {
     QStringList args;
     args <<  QStringLiteral("kwindecoration");
     if (controlCenter)
         args << QStringLiteral("kwinoptions");
     else if (KAuthorized::authorizeControlModule(QStringLiteral("kde-kwinoptions.desktop")))
         args << QStringLiteral("kwinactions") << QStringLiteral("kwinfocus") <<  QStringLiteral("kwinmoving") << QStringLiteral("kwinadvanced")
              << QStringLiteral("kwinrules") << QStringLiteral("kwincompositing") << QStringLiteral("kwineffects")
 #ifdef KWIN_BUILD_TABBOX
              << QStringLiteral("kwintabbox")
 #endif
              << QStringLiteral("kwinscreenedges")
              << QStringLiteral("kwinscripts")
              ;
     return args;
 }
 
 void UserActionsMenu::init()
 {
     if (m_menu) {
         return;
     }
     m_menu = new QMenu;
     connect(m_menu, &QMenu::aboutToShow, this, &UserActionsMenu::menuAboutToShow);
     connect(m_menu, &QMenu::triggered, this, &UserActionsMenu::slotWindowOperation, Qt::QueuedConnection);
 
     QMenu *advancedMenu = new QMenu(m_menu);
     connect(advancedMenu, &QMenu::aboutToShow, [this, advancedMenu]() {
         if (m_client) {
             advancedMenu->setPalette(m_client->palette());
         }
     });
 
     auto setShortcut = [](QAction *action, const QString &actionName) {
         const auto shortcuts = KGlobalAccel::self()->shortcut(Workspace::self()->findChild<QAction*>(actionName));
         if (!shortcuts.isEmpty()) {
             action->setShortcut(shortcuts.first());
         }
     };
 
     m_moveOperation = advancedMenu->addAction(i18n("&Move"));
     m_moveOperation->setIcon(QIcon::fromTheme(QStringLiteral("transform-move")));
     setShortcut(m_moveOperation, QStringLiteral("Window Move"));
     m_moveOperation->setData(Options::UnrestrictedMoveOp);
 
     m_resizeOperation = advancedMenu->addAction(i18n("&Resize"));
     m_resizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("transform-scale")));
     setShortcut(m_resizeOperation, QStringLiteral("Window Resize"));
     m_resizeOperation->setData(Options::ResizeOp);
 
     m_keepAboveOperation = advancedMenu->addAction(i18n("Keep &Above Others"));
     m_keepAboveOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-keep-above")));
     setShortcut(m_keepAboveOperation, QStringLiteral("Window Above Other Windows"));
     m_keepAboveOperation->setCheckable(true);
     m_keepAboveOperation->setData(Options::KeepAboveOp);
 
     m_keepBelowOperation = advancedMenu->addAction(i18n("Keep &Below Others"));
     m_keepBelowOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-keep-below")));
     setShortcut(m_keepBelowOperation, QStringLiteral("Window Below Other Windows"));
     m_keepBelowOperation->setCheckable(true);
     m_keepBelowOperation->setData(Options::KeepBelowOp);
 
     m_fullScreenOperation = advancedMenu->addAction(i18n("&Fullscreen"));
     m_fullScreenOperation->setIcon(QIcon::fromTheme(QStringLiteral("view-fullscreen")));
     setShortcut(m_fullScreenOperation, QStringLiteral("Window Fullscreen"));
     m_fullScreenOperation->setCheckable(true);
     m_fullScreenOperation->setData(Options::FullScreenOp);
 
     m_shadeOperation = advancedMenu->addAction(i18n("&Shade"));
     m_shadeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-shade")));
     setShortcut(m_shadeOperation, QStringLiteral("Window Shade"));
     m_shadeOperation->setCheckable(true);
     m_shadeOperation->setData(Options::ShadeOp);
 
     m_noBorderOperation = advancedMenu->addAction(i18n("&No Border"));
     m_noBorderOperation->setIcon(QIcon::fromTheme(QStringLiteral("edit-none-border")));
     setShortcut(m_noBorderOperation, QStringLiteral("Window No Border"));
     m_noBorderOperation->setCheckable(true);
     m_noBorderOperation->setData(Options::NoBorderOp);
 
     advancedMenu->addSeparator();
 
     m_shortcutOperation = advancedMenu->addAction(i18n("Set Window Short&cut..."));
     m_shortcutOperation->setIcon(QIcon::fromTheme(QStringLiteral("configure-shortcuts")));
     setShortcut(m_shortcutOperation, QStringLiteral("Setup Window Shortcut"));
     m_shortcutOperation->setData(Options::SetupWindowShortcutOp);
 
     QAction *action = advancedMenu->addAction(i18n("Configure Special &Window Settings..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-windows-actions")));
     action->setData(Options::WindowRulesOp);
     m_rulesOperation = action;
 
     action = advancedMenu->addAction(i18n("Configure S&pecial Application Settings..."));
     action->setIcon(QIcon::fromTheme(QStringLiteral("preferences-system-windows-actions")));
     action->setData(Options::ApplicationRulesOp);
     m_applicationRulesOperation = action;
     if (!kwinApp()->config()->isImmutable() &&
             !KAuthorized::authorizeControlModules(configModules(true)).isEmpty()) {
         advancedMenu->addSeparator();
         action = advancedMenu->addAction(i18nc("Entry in context menu of window decoration to open the configuration module of KWin",
                                         "Configure W&indow Manager..."));
         action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
         connect(action, &QAction::triggered, this,
             [this]() {
                 // opens the KWin configuration
                 QStringList args;
                 args << QStringLiteral("--icon") << QStringLiteral("preferences-system-windows");
                 const QString path = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                             QStringLiteral("kservices5/kwinfocus.desktop"));
                 if (!path.isEmpty()) {
                     args << QStringLiteral("--desktopfile") << path;
                 }
                 args << configModules(false);
                 QProcess *p = new Process(this);
                 p->setArguments(args);
                 p->setProcessEnvironment(kwinApp()->processStartupEnvironment());
                 p->setProgram(QStringLiteral("kcmshell5"));
                 connect(p, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), p, &QProcess::deleteLater);
                 connect(p, &QProcess::errorOccurred, this, [] (QProcess::ProcessError e) {
                     if (e == QProcess::FailedToStart) {
                         qCDebug(KWIN_CORE) << "Failed to start kcmshell5";
                     }
                 });
                 p->start();
             }
         );
     }
 
     m_maximizeOperation = m_menu->addAction(i18n("Ma&ximize"));
     m_maximizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-maximize")));
     setShortcut(m_maximizeOperation, QStringLiteral("Window Maximize"));
     m_maximizeOperation->setCheckable(true);
     m_maximizeOperation->setData(Options::MaximizeOp);
 
     m_minimizeOperation = m_menu->addAction(i18n("Mi&nimize"));
     m_minimizeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-minimize")));
     setShortcut(m_minimizeOperation, QStringLiteral("Window Minimize"));
     m_minimizeOperation->setData(Options::MinimizeOp);
 
     action = m_menu->addMenu(advancedMenu);
     action->setText(i18n("&More Actions"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("view-more-symbolic")));
 
     m_closeOperation = m_menu->addAction(i18n("&Close"));
     m_closeOperation->setIcon(QIcon::fromTheme(QStringLiteral("window-close")));
     setShortcut(m_closeOperation, QStringLiteral("Window Close"));
     m_closeOperation->setData(Options::CloseOp);
 }
 
 void UserActionsMenu::discard()
 {
     delete m_menu;
     m_menu = nullptr;
     m_desktopMenu = nullptr;
     m_multipleDesktopsMenu = nullptr;
     m_screenMenu = nullptr;
     m_activityMenu = nullptr;
     m_scriptsMenu = nullptr;
 }
 
 void UserActionsMenu::menuAboutToShow()
 {
     if (m_client.isNull() || !m_menu)
         return;
 
     if (VirtualDesktopManager::self()->count() == 1) {
         delete m_desktopMenu;
         m_desktopMenu = nullptr;
         delete m_multipleDesktopsMenu;
         m_multipleDesktopsMenu = nullptr;
     } else {
         initDesktopPopup();
     }
     if (screens()->count() == 1 || (!m_client->isMovable() && !m_client->isMovableAcrossScreens())) {
         delete m_screenMenu;
         m_screenMenu = nullptr;
     } else {
         initScreenPopup();
     }
 
     m_menu->setPalette(m_client->palette());
     m_resizeOperation->setEnabled(m_client->isResizable());
     m_moveOperation->setEnabled(m_client->isMovableAcrossScreens());
     m_maximizeOperation->setEnabled(m_client->isMaximizable());
     m_maximizeOperation->setChecked(m_client->maximizeMode() == MaximizeFull);
     m_shadeOperation->setEnabled(m_client->isShadeable());
     m_shadeOperation->setChecked(m_client->shadeMode() != ShadeNone);
     m_keepAboveOperation->setChecked(m_client->keepAbove());
     m_keepBelowOperation->setChecked(m_client->keepBelow());
     m_fullScreenOperation->setEnabled(m_client->userCanSetFullScreen());
     m_fullScreenOperation->setChecked(m_client->isFullScreen());
     m_noBorderOperation->setEnabled(m_client->userCanSetNoBorder());
     m_noBorderOperation->setChecked(m_client->noBorder());
     m_minimizeOperation->setEnabled(m_client->isMinimizable());
     m_closeOperation->setEnabled(m_client->isCloseable());
     m_shortcutOperation->setEnabled(m_client->rules()->checkShortcut(QString()).isNull());
 
     // drop the existing scripts menu
     delete m_scriptsMenu;
     m_scriptsMenu = nullptr;
     // ask scripts whether they want to add entries for the given Client
     QList<QAction*> scriptActions = Scripting::self()->actionsForUserActionMenu(m_client.data(), m_scriptsMenu);
     if (!scriptActions.isEmpty()) {
         m_scriptsMenu = new QMenu(m_menu);
         m_scriptsMenu->setPalette(m_client->palette());
         m_scriptsMenu->addActions(scriptActions);
 
         QAction *action = m_scriptsMenu->menuAction();
         // set it as the first item after desktop
         m_menu->insertAction(m_closeOperation, action);
         action->setText(i18n("&Extensions"));
     }
 
     m_rulesOperation->setEnabled(m_client->supportsWindowRules());
     m_applicationRulesOperation->setEnabled(m_client->supportsWindowRules());
 
     showHideActivityMenu();
 }
 
 void UserActionsMenu::showHideActivityMenu()
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     const QStringList &openActivities_ = Activities::self()->running();
     qCDebug(KWIN_CORE) << "activities:" << openActivities_.size();
     if (openActivities_.size() < 2) {
         delete m_activityMenu;
         m_activityMenu = nullptr;
     } else {
         initActivityPopup();
     }
 #endif
 }
 
 void UserActionsMenu::initDesktopPopup()
 {
     if (kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
         kwinApp()->operationMode() == Application::OperationModeXwayland) {
         if (m_multipleDesktopsMenu) {
             return;
         }
 
         m_multipleDesktopsMenu = new QMenu(m_menu);
         connect(m_multipleDesktopsMenu, &QMenu::triggered, this,   &UserActionsMenu::slotToggleOnVirtualDesktop);
         connect(m_multipleDesktopsMenu, &QMenu::aboutToShow, this, &UserActionsMenu::multipleDesktopsPopupAboutToShow);
 
         QAction *action = m_multipleDesktopsMenu->menuAction();
         // set it as the first item
         m_menu->insertAction(m_maximizeOperation, action);
         action->setText(i18n("&Desktops"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("virtual-desktops")));
 
     } else {
         if (m_desktopMenu)
             return;
 
         m_desktopMenu = new QMenu(m_menu);
         connect(m_desktopMenu, &QMenu::triggered,   this, &UserActionsMenu::slotSendToDesktop);
         connect(m_desktopMenu, &QMenu::aboutToShow, this, &UserActionsMenu::desktopPopupAboutToShow);
 
         QAction *action = m_desktopMenu->menuAction();
         // set it as the first item
         m_menu->insertAction(m_maximizeOperation, action);
         action->setText(i18n("Move to &Desktop"));
         action->setIcon(QIcon::fromTheme(QStringLiteral("virtual-desktops")));
     }
 }
 
 void UserActionsMenu::initScreenPopup()
 {
     if (m_screenMenu) {
         return;
     }
 
     m_screenMenu = new QMenu(m_menu);
     connect(m_screenMenu, &QMenu::triggered,   this, &UserActionsMenu::slotSendToScreen);
     connect(m_screenMenu, &QMenu::aboutToShow, this, &UserActionsMenu::screenPopupAboutToShow);
 
     QAction *action = m_screenMenu->menuAction();
     // set it as the first item after desktop
     m_menu->insertAction(m_activityMenu ? m_activityMenu->menuAction() : m_minimizeOperation, action);
     action->setText(i18n("Move to &Screen"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("computer")));
 }
 
 void UserActionsMenu::initActivityPopup()
 {
     if (m_activityMenu)
         return;
 
     m_activityMenu = new QMenu(m_menu);
     connect(m_activityMenu, &QMenu::triggered, this,   &UserActionsMenu::slotToggleOnActivity);
     connect(m_activityMenu, &QMenu::aboutToShow, this, &UserActionsMenu::activityPopupAboutToShow);
 
     QAction *action = m_activityMenu->menuAction();
     // set it as the first item
     m_menu->insertAction(m_maximizeOperation, action);
     action->setText(i18n("Show in &Activities"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("activities")));
 }
 
 void UserActionsMenu::desktopPopupAboutToShow()
 {
     if (!m_desktopMenu)
         return;
     const VirtualDesktopManager *vds = VirtualDesktopManager::self();
 
     m_desktopMenu->clear();
     if (m_client) {
         m_desktopMenu->setPalette(m_client->palette());
     }
     QActionGroup *group = new QActionGroup(m_desktopMenu);
     QAction *action = m_desktopMenu->addAction(i18n("&All Desktops"));
     action->setData(0);
     action->setCheckable(true);
     group->addAction(action);
 
     if (m_client && m_client->isOnAllDesktops()) {
         action->setChecked(true);
     }
     m_desktopMenu->addSeparator();
 
     const uint BASE = 10;
 
     for (uint i = 1; i <= vds->count(); ++i) {
         QString basic_name(QStringLiteral("%1  %2"));
         if (i < BASE) {
             basic_name.prepend(QLatin1Char('&'));
         }
         action = m_desktopMenu->addAction(basic_name.arg(i).arg(vds->name(i).replace(QLatin1Char('&'), QStringLiteral("&&"))));
         action->setData(i);
         action->setCheckable(true);
         group->addAction(action);
 
         if (m_client && !m_client->isOnAllDesktops() && m_client->isOnDesktop(i)) {
             action->setChecked(true);
         }
     }
 
     m_desktopMenu->addSeparator();
     action = m_desktopMenu->addAction(i18nc("Create a new desktop and move there the window", "&New Desktop"));
     action->setData(vds->count() + 1);
 
     if (vds->count() >= vds->maximum())
         action->setEnabled(false);
 }
 
 void UserActionsMenu::multipleDesktopsPopupAboutToShow()
 {
     if (!m_multipleDesktopsMenu)
         return;
     const VirtualDesktopManager *vds = VirtualDesktopManager::self();
 
     m_multipleDesktopsMenu->clear();
     if (m_client) {
         m_multipleDesktopsMenu->setPalette(m_client->palette());
     }
     QAction *action = m_multipleDesktopsMenu->addAction(i18n("&All Desktops"));
     action->setData(0);
     action->setCheckable(true);
     QActionGroup *allDesktopsGroup = new QActionGroup(m_multipleDesktopsMenu);
     allDesktopsGroup->addAction(action);
 
     if (m_client && m_client->isOnAllDesktops()) {
         action->setChecked(true);
     }
     m_multipleDesktopsMenu->addSeparator();
 
 
     const uint BASE = 10;
 
     for (uint i = 1; i <= vds->count(); ++i) {
         QString basic_name(QStringLiteral("%1  %2"));
         if (i < BASE) {
             basic_name.prepend(QLatin1Char('&'));
         }
         QWidgetAction *action = new QWidgetAction(m_multipleDesktopsMenu);
         QCheckBox *box = new QCheckBox(basic_name.arg(i).arg(vds->name(i).replace(QLatin1Char('&'), QStringLiteral("&&"))), m_multipleDesktopsMenu);
         action->setDefaultWidget(box);
 
         box->setBackgroundRole(m_multipleDesktopsMenu->backgroundRole());
         box->setForegroundRole(m_multipleDesktopsMenu->foregroundRole());
         box->setPalette(m_multipleDesktopsMenu->palette());
         connect(box, &QCheckBox::clicked, action, &QAction::triggered);
         m_multipleDesktopsMenu->addAction(action);
         action->setData(i);
 
         if (m_client && !m_client->isOnAllDesktops() && m_client->isOnDesktop(i)) {
             box->setChecked(true);
         }
     }
 
     m_multipleDesktopsMenu->addSeparator();
     action = m_multipleDesktopsMenu->addAction(i18nc("Create a new desktop and move there the window", "&New Desktop"));
     action->setData(vds->count() + 1);
 
     if (vds->count() >= vds->maximum())
         action->setEnabled(false);
 }
 
 void UserActionsMenu::screenPopupAboutToShow()
 {
     if (!m_screenMenu) {
         return;
     }
     m_screenMenu->clear();
 
     if (!m_client) {
         return;
     }
     m_screenMenu->setPalette(m_client->palette());
     QActionGroup *group = new QActionGroup(m_screenMenu);
 
     for (int i = 0; i<screens()->count(); ++i) {
         // assumption: there are not more than 9 screens attached.
         QAction *action = m_screenMenu->addAction(i18nc("@item:inmenu List of all Screens to send a window to. First argument is a number, second the output identifier. E.g. Screen 1 (HDMI1)",
                                                         "Screen &%1 (%2)", (i+1), screens()->name(i)));
         action->setData(i);
         action->setCheckable(true);
         if (m_client && i == m_client->screen()) {
             action->setChecked(true);
         }
         group->addAction(action);
     }
 }
 
 void UserActionsMenu::activityPopupAboutToShow()
 {
     if (!m_activityMenu)
         return;
 
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     m_activityMenu->clear();
     if (m_client) {
         m_activityMenu->setPalette(m_client->palette());
     }
     QAction *action = m_activityMenu->addAction(i18n("&All Activities"));
     action->setData(QString());
     action->setCheckable(true);
     static QPointer<QActionGroup> allActivitiesGroup;
     if (!allActivitiesGroup) {
         allActivitiesGroup = new QActionGroup(m_activityMenu);
     }
     allActivitiesGroup->addAction(action);
 
     if (m_client && m_client->isOnAllActivities()) {
         action->setChecked(true);
     }
     m_activityMenu->addSeparator();
 
     foreach (const QString &id, Activities::self()->running()) {
         KActivities::Info activity(id);
         QString name = activity.name();
         name.replace('&', "&&");
         QWidgetAction *action = new QWidgetAction(m_activityMenu);
         QCheckBox *box = new QCheckBox(name, m_activityMenu);
         action->setDefaultWidget(box);
         const QString icon = activity.icon();
         if (!icon.isEmpty())
             box->setIcon(QIcon::fromTheme(icon));
         box->setBackgroundRole(m_activityMenu->backgroundRole());
         box->setForegroundRole(m_activityMenu->foregroundRole());
         box->setPalette(m_activityMenu->palette());
         connect(box, &QCheckBox::clicked, action, &QAction::triggered);
         m_activityMenu->addAction(action);
         action->setData(id);
 
         if (m_client && !m_client->isOnAllActivities() && m_client->isOnActivity(id)) {
             box->setChecked(true);
         }
     }
 #endif
 }
 
 void UserActionsMenu::slotWindowOperation(QAction *action)
 {
     if (!action->data().isValid())
         return;
 
     Options::WindowOperation op = static_cast< Options::WindowOperation >(action->data().toInt());
     QPointer<AbstractClient> c = m_client ? m_client : QPointer<AbstractClient>(Workspace::self()->activeClient());
     if (c.isNull())
         return;
     QString type;
     switch(op) {
     case Options::FullScreenOp:
         if (!c->isFullScreen() && c->userCanSetFullScreen())
             type = QStringLiteral("fullscreenaltf3");
         break;
     case Options::NoBorderOp:
         if (!c->noBorder() && c->userCanSetNoBorder())
             type = QStringLiteral("noborderaltf3");
         break;
     default:
         break;
     }
     if (!type.isEmpty())
         helperDialog(type, c);
     // need to delay performing the window operation as we need to have the
     // user actions menu closed before we destroy the decoration. Otherwise Qt crashes
     qRegisterMetaType<Options::WindowOperation>();
     QMetaObject::invokeMethod(workspace(), "performWindowOperation",
                               Qt::QueuedConnection,
                               Q_ARG(KWin::AbstractClient*, c),
                               Q_ARG(Options::WindowOperation, op));
 }
 
 void UserActionsMenu::slotSendToDesktop(QAction *action)
 {
     bool ok = false;
     uint desk = action->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     if (m_client.isNull())
         return;
     Workspace *ws = Workspace::self();
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     if (desk == 0) {
         // the 'on_all_desktops' menu entry
         if (m_client) {
             m_client->setOnAllDesktops(!m_client->isOnAllDesktops());
         }
         return;
     } else if (desk > vds->count()) {
         vds->setCount(desk);
     }
 
     ws->sendClientToDesktop(m_client.data(), desk, false);
 }
 
 void UserActionsMenu::slotToggleOnVirtualDesktop(QAction *action)
 {
     bool ok = false;
     uint desk = action->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     if (m_client.isNull()) {
         return;
     }
 
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     if (desk == 0) {
         // the 'on_all_desktops' menu entry
         m_client->setOnAllDesktops(!m_client->isOnAllDesktops());
         return;
     } else if (desk > vds->count()) {
         vds->setCount(desk);
     }
 
     VirtualDesktop *virtualDesktop = VirtualDesktopManager::self()->desktopForX11Id(desk);
     if (m_client->desktops().contains(virtualDesktop)) {
         m_client->leaveDesktop(virtualDesktop);
     } else {
         m_client->enterDesktop(virtualDesktop);
     }
 }
 
 void UserActionsMenu::slotSendToScreen(QAction *action)
 {
     const int screen = action->data().toInt();
     if (m_client.isNull()) {
         return;
     }
     if (screen >= screens()->count()) {
         return;
     }
 
     Workspace::self()->sendClientToScreen(m_client.data(), screen);
 }
 
 void UserActionsMenu::slotToggleOnActivity(QAction *action)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     QString activity = action->data().toString();
     if (m_client.isNull())
         return;
     if (activity.isEmpty()) {
         // the 'on_all_activities' menu entry
         m_client->setOnAllActivities(!m_client->isOnAllActivities());
         return;
     }
 
     X11Client *c = dynamic_cast<X11Client *>(m_client.data());
     if (!c) {
         return;
     }
 
     Activities::self()->toggleClientOnActivity(c, activity, false);
     if (m_activityMenu && m_activityMenu->isVisible() && m_activityMenu->actions().count()) {
         const bool isOnAll = m_client->isOnAllActivities();
         m_activityMenu->actions().at(0)->setChecked(isOnAll);
         if (isOnAll) {
             // toggleClientOnActivity interprets "on all" as "on none" and
             // susequent toggling ("off") would move the client to only that activity.
             // bug #330838 -> set all but "on all" off to "force proper usage"
             for (int i = 1; i < m_activityMenu->actions().count(); ++i) {
                 if (QWidgetAction *qwa = qobject_cast<QWidgetAction*>(m_activityMenu->actions().at(i))) {
                     if (QCheckBox *qcb = qobject_cast<QCheckBox*>(qwa->defaultWidget())) {
                         qcb->setChecked(false);
                     }
                 }
             }
         }
     }
 #else
     Q_UNUSED(action)
 #endif
 }
 
 //****************************************
 // ShortcutDialog
 //****************************************
 ShortcutDialog::ShortcutDialog(const QKeySequence& cut)
     : _shortcut(cut)
 {
     m_ui.setupUi(this);
     m_ui.keySequenceEdit->setKeySequence(cut);
     m_ui.warning->hide();
 
     // Listen to changed shortcuts
     connect(m_ui.keySequenceEdit, &QKeySequenceEdit::editingFinished, this, &ShortcutDialog::keySequenceChanged);
     connect(m_ui.clearButton, &QToolButton::clicked, [this]{
         _shortcut = QKeySequence();
     });
     m_ui.keySequenceEdit->setFocus();
 
     setWindowFlags(Qt::Popup | Qt::X11BypassWindowManagerHint);
 }
 
 void ShortcutDialog::accept()
 {
     QKeySequence seq = shortcut();
     if (!seq.isEmpty()) {
         if (seq[0] == Qt::Key_Escape) {
             reject();
             return;
         }
         if (seq[0] == Qt::Key_Space
         || (seq[0] & Qt::KeyboardModifierMask) == 0) {
             // clear
             m_ui.keySequenceEdit->clear();
             QDialog::accept();
             return;
         }
     }
     QDialog::accept();
 }
 
 void ShortcutDialog::done(int r)
 {
     QDialog::done(r);
     emit dialogDone(r == Accepted);
 }
 
 void ShortcutDialog::keySequenceChanged()
 {
     activateWindow(); // where is the kbd focus lost? cause of popup state?
     QKeySequence seq = m_ui.keySequenceEdit->keySequence();
     if (_shortcut == seq)
         return; // don't try to update the same
 
     if (seq.isEmpty()) { // clear
         _shortcut = seq;
         return;
     }
     if (seq.count() > 1) {
         seq = QKeySequence(seq[0]);
         m_ui.keySequenceEdit->setKeySequence(seq);
     }
 
     // Check if the key sequence is used currently
     QString sc = seq.toString();
     // NOTICE - seq.toString() & the entries in "conflicting" randomly get invalidated after the next call (if no sc has been set & conflicting isn't empty?!)
     QList<KGlobalShortcutInfo> conflicting = KGlobalAccel::getGlobalShortcutsByKey(seq);
     if (!conflicting.isEmpty()) {
         const KGlobalShortcutInfo &conflict = conflicting.at(0);
         m_ui.warning->setText(i18nc("'%1' is a keyboard shortcut like 'ctrl+w'",
         "<b>%1</b> is already in use", sc));
         m_ui.warning->setToolTip(i18nc("keyboard shortcut '%1' is used by action '%2' in application '%3'",
         "<b>%1</b> is used by %2 in %3", sc, conflict.friendlyName(), conflict.componentFriendlyName()));
         m_ui.warning->show();
         m_ui.keySequenceEdit->setKeySequence(shortcut());
     } else if (seq != _shortcut) {
         m_ui.warning->hide();
         if (QPushButton *ok = m_ui.buttonBox->button(QDialogButtonBox::Ok))
             ok->setFocus();
     }
 
     _shortcut = seq;
 }
 
 QKeySequence ShortcutDialog::shortcut() const
 {
     return _shortcut;
 }
 
 //****************************************
 // Workspace
 //****************************************
 
 void Workspace::slotIncreaseWindowOpacity()
 {
     if (!active_client) {
         return;
     }
     active_client->setOpacity(qMin(active_client->opacity() + 0.05, 1.0));
 }
 
 void Workspace::slotLowerWindowOpacity()
 {
     if (!active_client) {
         return;
     }
     active_client->setOpacity(qMax(active_client->opacity() - 0.05, 0.05));
 }
 
 void Workspace::closeActivePopup()
 {
     if (active_popup) {
         active_popup->close();
         active_popup = nullptr;
         active_popup_client = nullptr;
     }
     m_userActionsMenu->close();
 }
 
 
 template <typename Slot>
 void Workspace::initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut, Slot slot, const QVariant &data)
 {
     initShortcut(actionName, description, shortcut, this, slot, data);
 }
 
 template <typename T, typename Slot>
 void Workspace::initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut, T *receiver, Slot slot, const QVariant &data)
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(actionName);
     a->setText(description);
     if (data.isValid()) {
         a->setData(data);
     }
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << shortcut);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << shortcut);
     input()->registerShortcut(shortcut, a, receiver, slot);
 }
 
 /**
  * Creates the global accel object \c keys.
  */
 void Workspace::initShortcuts()
 {
 #define IN_KWIN
 #include "kwinbindings.cpp"
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->initShortcuts();
 #endif
     VirtualDesktopManager::self()->initShortcuts();
     kwinApp()->platform()->colorCorrectManager()->initShortcuts();
     m_userActionsMenu->discard(); // so that it's recreated next time
 }
 
 void Workspace::setupWindowShortcut(AbstractClient* c)
 {
     Q_ASSERT(client_keys_dialog == nullptr);
     // TODO: PORT ME (KGlobalAccel related)
     //keys->setEnabled( false );
     //disable_shortcuts_keys->setEnabled( false );
     //client_keys->setEnabled( false );
     client_keys_dialog = new ShortcutDialog(c->shortcut());
     client_keys_client = c;
     connect(client_keys_dialog, &ShortcutDialog::dialogDone, this, &Workspace::setupWindowShortcutDone);
     QRect r = clientArea(ScreenArea, c);
     QSize size = client_keys_dialog->sizeHint();
     QPoint pos = c->pos() + c->clientPos();
     if (pos.x() + size.width() >= r.right())
         pos.setX(r.right() - size.width());
     if (pos.y() + size.height() >= r.bottom())
         pos.setY(r.bottom() - size.height());
     client_keys_dialog->move(pos);
     client_keys_dialog->show();
     active_popup = client_keys_dialog;
     active_popup_client = c;
 }
 
 void Workspace::setupWindowShortcutDone(bool ok)
 {
 //    keys->setEnabled( true );
 //    disable_shortcuts_keys->setEnabled( true );
 //    client_keys->setEnabled( true );
     if (ok)
         client_keys_client->setShortcut(client_keys_dialog->shortcut().toString());
     closeActivePopup();
     client_keys_dialog->deleteLater();
     client_keys_dialog = nullptr;
     client_keys_client = nullptr;
     if (active_client)
         active_client->takeFocus();
 }
 
 void Workspace::clientShortcutUpdated(AbstractClient* c)
 {
     QString key = QStringLiteral("_k_session:%1").arg(c->window());
     QAction* action = findChild<QAction*>(key);
     if (!c->shortcut().isEmpty()) {
         if (action == nullptr) { // new shortcut
             action = new QAction(this);
             kwinApp()->platform()->setupActionForGlobalAccel(action);
             action->setProperty("componentName", QStringLiteral(KWIN_NAME));
             action->setObjectName(key);
             action->setText(i18n("Activate Window (%1)", c->caption()));
             connect(action, &QAction::triggered, c, std::bind(&Workspace::activateClient, this, c, true));
         }
 
         // no autoloading, since it's configured explicitly here and is not meant to be reused
         // (the key is the window id anyway, which is kind of random)
         KGlobalAccel::self()->setShortcut(action, QList<QKeySequence>() << c->shortcut(),
                                           KGlobalAccel::NoAutoloading);
         action->setEnabled(true);
     } else {
         KGlobalAccel::self()->removeAllShortcuts(action);
         delete action;
     }
 }
 
 void Workspace::performWindowOperation(AbstractClient* c, Options::WindowOperation op)
 {
     if (!c)
         return;
     if (op == Options::MoveOp || op == Options::UnrestrictedMoveOp)
         Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     if (op == Options::ResizeOp || op == Options::UnrestrictedResizeOp)
         Cursors::self()->mouse()->setPos(c->frameGeometry().bottomRight());
     switch(op) {
     case Options::MoveOp:
         c->performMouseCommand(Options::MouseMove, Cursors::self()->mouse()->pos());
         break;
     case Options::UnrestrictedMoveOp:
         c->performMouseCommand(Options::MouseUnrestrictedMove, Cursors::self()->mouse()->pos());
         break;
     case Options::ResizeOp:
         c->performMouseCommand(Options::MouseResize, Cursors::self()->mouse()->pos());
         break;
     case Options::UnrestrictedResizeOp:
         c->performMouseCommand(Options::MouseUnrestrictedResize, Cursors::self()->mouse()->pos());
         break;
     case Options::CloseOp:
         QMetaObject::invokeMethod(c, "closeWindow", Qt::QueuedConnection);
         break;
     case Options::MaximizeOp:
         c->maximize(c->maximizeMode() == MaximizeFull
                     ? MaximizeRestore : MaximizeFull);
         break;
     case Options::HMaximizeOp:
         c->maximize(c->maximizeMode() ^ MaximizeHorizontal);
         break;
     case Options::VMaximizeOp:
         c->maximize(c->maximizeMode() ^ MaximizeVertical);
         break;
     case Options::RestoreOp:
         c->maximize(MaximizeRestore);
         break;
     case Options::MinimizeOp:
         c->minimize();
         break;
     case Options::ShadeOp:
         c->performMouseCommand(Options::MouseShade, Cursors::self()->mouse()->pos());
         break;
     case Options::OnAllDesktopsOp:
         c->setOnAllDesktops(!c->isOnAllDesktops());
         break;
     case Options::FullScreenOp:
         c->setFullScreen(!c->isFullScreen(), true);
         break;
     case Options::NoBorderOp:
         c->setNoBorder(!c->noBorder());
         break;
     case Options::KeepAboveOp: {
         StackingUpdatesBlocker blocker(this);
         bool was = c->keepAbove();
         c->setKeepAbove(!c->keepAbove());
         if (was && !c->keepAbove())
             raiseClient(c);
         break;
     }
     case Options::KeepBelowOp: {
         StackingUpdatesBlocker blocker(this);
         bool was = c->keepBelow();
         c->setKeepBelow(!c->keepBelow());
         if (was && !c->keepBelow())
             lowerClient(c);
         break;
     }
     case Options::OperationsOp:
         c->performMouseCommand(Options::MouseShade, Cursors::self()->mouse()->pos());
         break;
     case Options::WindowRulesOp:
         RuleBook::self()->edit(c, false);
         break;
     case Options::ApplicationRulesOp:
         RuleBook::self()->edit(c, true);
         break;
     case Options::SetupWindowShortcutOp:
         setupWindowShortcut(c);
         break;
     case Options::LowerOp:
         lowerClient(c);
         break;
     case Options::NoOp:
         break;
     }
 }
 
-/**
- * Performs a mouse command on this client (see options.h)
- */
-bool X11Client::performMouseCommand(Options::MouseCommand command, const QPoint &globalPos)
-{
-    bool replay = false;
-    switch(command) {
-    case Options::MouseShade :
-        toggleShade();
-        cancelShadeHoverTimer();
-        break;
-    case Options::MouseSetShade:
-        setShade(ShadeNormal);
-        cancelShadeHoverTimer();
-        break;
-    case Options::MouseUnsetShade:
-        setShade(ShadeNone);
-        cancelShadeHoverTimer();
-        break;
-    default:
-        return AbstractClient::performMouseCommand(command, globalPos);
-    }
-    return replay;
-}
-
 void Workspace::slotActivateAttentionWindow()
 {
     if (attention_chain.count() > 0)
         activateClient(attention_chain.first());
 }
 
 static uint senderValue(QObject *sender)
 {
     QAction *act = qobject_cast<QAction*>(sender);
     bool ok = false; uint i = -1;
     if (act)
         i = act->data().toUInt(&ok);
     if (ok)
         return i;
     return -1;
 }
 
 #define USABLE_ACTIVE_CLIENT (active_client && !(active_client->isDesktop() || active_client->isDock()))
 
 void Workspace::slotWindowToDesktop(uint i)
 {
     if (USABLE_ACTIVE_CLIENT) {
         if (i < 1)
             return;
 
         if (i >= 1 && i <= VirtualDesktopManager::self()->count())
             sendClientToDesktop(active_client, i, true);
     }
 }
 
 static bool screenSwitchImpossible()
 {
     if (!screens()->isCurrentFollowsMouse())
         return false;
     QStringList args;
     args << QStringLiteral("--passivepopup") << i18n("The window manager is configured to consider the screen with the mouse on it as active one.\n"
                                      "Therefore it is not possible to switch to a screen explicitly.") << QStringLiteral("20");
     KProcess::startDetached(QStringLiteral("kdialog"), args);
     return true;
 }
 
 void Workspace::slotSwitchToScreen()
 {
     if (screenSwitchImpossible())
         return;
     const int i = senderValue(sender());
     if (i > -1)
         setCurrentScreen(i);
 }
 
 void Workspace::slotSwitchToNextScreen()
 {
     if (screenSwitchImpossible())
         return;
     setCurrentScreen((screens()->current() + 1) % screens()->count());
 }
 
 void Workspace::slotSwitchToPrevScreen()
 {
     if (screenSwitchImpossible())
         return;
     setCurrentScreen((screens()->current() + screens()->count() - 1) % screens()->count());
 }
 
 void Workspace::slotWindowToScreen()
 {
     if (USABLE_ACTIVE_CLIENT) {
         const int i = senderValue(sender());
         if (i < 0)
             return;
         if (i >= 0 && i <= screens()->count()) {
             sendClientToScreen(active_client, i);
         }
     }
 }
 
 void Workspace::slotWindowToNextScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         sendClientToScreen(active_client, (active_client->screen() + 1) % screens()->count());
 }
 
 void Workspace::slotWindowToPrevScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         sendClientToScreen(active_client, (active_client->screen() + screens()->count() - 1) % screens()->count());
 }
 
 /**
  * Maximizes the active client.
  */
 void Workspace::slotWindowMaximize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::MaximizeOp);
 }
 
 /**
  * Maximizes the active client vertically.
  */
 void Workspace::slotWindowMaximizeVertical()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::VMaximizeOp);
 }
 
 /**
  * Maximizes the active client horiozontally.
  */
 void Workspace::slotWindowMaximizeHorizontal()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::HMaximizeOp);
 }
 
 
 /**
  * Minimizes the active client.
  */
 void Workspace::slotWindowMinimize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::MinimizeOp);
 }
 
 /**
  * Shades/unshades the active client respectively.
  */
 void Workspace::slotWindowShade()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::ShadeOp);
 }
 
 /**
  * Raises the active client.
  */
 void Workspace::slotWindowRaise()
 {
     if (USABLE_ACTIVE_CLIENT)
         raiseClient(active_client);
 }
 
 /**
  * Lowers the active client.
  */
 void Workspace::slotWindowLower()
 {
     if (USABLE_ACTIVE_CLIENT) {
         lowerClient(active_client);
         // As this most likely makes the window no longer visible change the
         // keyboard focus to the next available window.
         //activateNextClient( c ); // Doesn't work when we lower a child window
         if (active_client->isActive() && options->focusPolicyIsReasonable()) {
             if (options->isNextFocusPrefersMouse()) {
                 AbstractClient *next = clientUnderMouse(active_client->screen());
                 if (next && next != active_client)
                     requestFocus(next, false);
             } else {
                 activateClient(topClientOnDesktop(VirtualDesktopManager::self()->current(), -1));
             }
         }
     }
 }
 
 /**
  * Does a toggle-raise-and-lower on the active client.
  */
 void Workspace::slotWindowRaiseOrLower()
 {
     if (USABLE_ACTIVE_CLIENT)
         raiseOrLowerClient(active_client);
 }
 
 void Workspace::slotWindowOnAllDesktops()
 {
     if (USABLE_ACTIVE_CLIENT)
         active_client->setOnAllDesktops(!active_client->isOnAllDesktops());
 }
 
 void Workspace::slotWindowFullScreen()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::FullScreenOp);
 }
 
 void Workspace::slotWindowNoBorder()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::NoBorderOp);
 }
 
 void Workspace::slotWindowAbove()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::KeepAboveOp);
 }
 
 void Workspace::slotWindowBelow()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::KeepBelowOp);
 }
 void Workspace::slotSetupWindowShortcut()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::SetupWindowShortcutOp);
 }
 
 /**
  * Toggles show desktop.
  */
 void Workspace::slotToggleShowDesktop()
 {
     setShowingDesktop(!showingDesktop());
 }
 
 template <typename Direction>
 void windowToDesktop(AbstractClient *c)
 {
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     Workspace *ws = Workspace::self();
     Direction functor;
     // TODO: why is options->isRollOverDesktops() not honored?
     const auto desktop = functor(nullptr, true);
     if (c && !c->isDesktop()
             && !c->isDock()) {
         ws->setMoveResizeClient(c);
         vds->setCurrent(desktop);
         ws->setMoveResizeClient(nullptr);
     }
 }
 
 /**
  * Moves the active client to the next desktop.
  */
 void Workspace::slotWindowToNextDesktop()
 {
     if (USABLE_ACTIVE_CLIENT)
         windowToNextDesktop(active_client);
 }
 
 void Workspace::windowToNextDesktop(AbstractClient* c)
 {
     windowToDesktop<DesktopNext>(c);
 }
 
 /**
  * Moves the active client to the previous desktop.
  */
 void Workspace::slotWindowToPreviousDesktop()
 {
     if (USABLE_ACTIVE_CLIENT)
         windowToPreviousDesktop(active_client);
 }
 
 void Workspace::windowToPreviousDesktop(AbstractClient* c)
 {
     windowToDesktop<DesktopPrevious>(c);
 }
 
 template <typename Direction>
 void activeClientToDesktop()
 {
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     Workspace *ws = Workspace::self();
     const int current = vds->current();
     Direction functor;
     const int d = functor(current, options->isRollOverDesktops());
     if (d == current) {
         return;
     }
     ws->setMoveResizeClient(ws->activeClient());
     vds->setCurrent(d);
     ws->setMoveResizeClient(nullptr);
 }
 
 void Workspace::slotWindowToDesktopRight()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopRight>();
     }
 }
 
 void Workspace::slotWindowToDesktopLeft()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopLeft>();
     }
 }
 
 void Workspace::slotWindowToDesktopUp()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopAbove>();
     }
 }
 
 void Workspace::slotWindowToDesktopDown()
 {
     if (USABLE_ACTIVE_CLIENT) {
         activeClientToDesktop<DesktopBelow>();
     }
 }
 
 /**
  * Kill Window feature, similar to xkill.
  */
 void Workspace::slotKillWindow()
 {
     if (m_windowKiller.isNull()) {
         m_windowKiller.reset(new KillWindow());
     }
     m_windowKiller->start();
 }
 
 /**
  * Switches to the nearest window in given direction.
  */
 void Workspace::switchWindow(Direction direction)
 {
     if (!active_client)
         return;
     AbstractClient *c = active_client;
     int desktopNumber = c->isOnAllDesktops() ? VirtualDesktopManager::self()->current() : c->desktop();
 
     // Centre of the active window
     QPoint curPos(c->x() + c->width() / 2, c->y() + c->height() / 2);
 
     if (!switchWindow(c, direction, curPos, desktopNumber)) {
         auto opposite = [&] {
             switch(direction) {
             case DirectionNorth:
                 return QPoint(curPos.x(), screens()->geometry().height());
             case DirectionSouth:
                 return QPoint(curPos.x(), 0);
             case DirectionEast:
                 return QPoint(0, curPos.y());
             case DirectionWest:
                 return QPoint(screens()->geometry().width(), curPos.y());
             default:
                 Q_UNREACHABLE();
             }
         };
 
         switchWindow(c, direction, opposite(), desktopNumber);
     }
 }
 
 bool Workspace::switchWindow(AbstractClient *c, Direction direction, QPoint curPos, int d)
 {
     AbstractClient *switchTo = nullptr;
     int bestScore = 0;
 
     QList<Toplevel *> clist = stackingOrder();
     for (auto i = clist.rbegin(); i != clist.rend(); ++i) {
         auto client = qobject_cast<AbstractClient*>(*i);
         if (!client) {
             continue;
         }
         if (client->wantsTabFocus() && *i != c &&
                 client->isOnDesktop(d) && !client->isMinimized() && (*i)->isOnCurrentActivity()) {
             // Centre of the other window
             const QPoint other(client->x() + client->width() / 2, client->y() + client->height() / 2);
 
             int distance;
             int offset;
             switch(direction) {
             case DirectionNorth:
                 distance = curPos.y() - other.y();
                 offset = qAbs(other.x() - curPos.x());
                 break;
             case DirectionEast:
                 distance = other.x() - curPos.x();
                 offset = qAbs(other.y() - curPos.y());
                 break;
             case DirectionSouth:
                 distance = other.y() - curPos.y();
                 offset = qAbs(other.x() - curPos.x());
                 break;
             case DirectionWest:
                 distance = curPos.x() - other.x();
                 offset = qAbs(other.y() - curPos.y());
                 break;
             default:
                 distance = -1;
                 offset = -1;
             }
 
             if (distance > 0) {
                 // Inverse score
                 int score = distance + offset + ((offset * offset) / distance);
                 if (score < bestScore || !switchTo) {
                     switchTo = client;
                     bestScore = score;
                 }
             }
         }
     }
     if (switchTo) {
         activateClient(switchTo);
     }
 
     return switchTo;
 }
 
 /**
  * Shows the window operations popup menu for the active client.
  */
 void Workspace::slotWindowOperations()
 {
     if (!active_client)
         return;
     QPoint pos = active_client->pos() + active_client->clientPos();
     showWindowMenu(QRect(pos, pos), active_client);
 }
 
 void Workspace::showWindowMenu(const QRect &pos, AbstractClient* cl)
 {
     m_userActionsMenu->show(pos, cl);
 }
 
 void Workspace::showApplicationMenu(const QRect &pos, AbstractClient *c, int actionId)
 {
     ApplicationMenu::self()->showApplicationMenu(c->pos() + pos.bottomLeft(), c, actionId);
 }
 
 /**
  * Closes the active client.
  */
 void Workspace::slotWindowClose()
 {
     // TODO: why?
 //     if ( tab_box->isVisible())
 //         return;
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::CloseOp);
 }
 
 /**
  * Starts keyboard move mode for the active client.
  */
 void Workspace::slotWindowMove()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::UnrestrictedMoveOp);
 }
 
 /**
  * Starts keyboard resize mode for the active client.
  */
 void Workspace::slotWindowResize()
 {
     if (USABLE_ACTIVE_CLIENT)
         performWindowOperation(active_client, Options::UnrestrictedResizeOp);
 }
 
 #undef USABLE_ACTIVE_CLIENT
 
 void AbstractClient::setShortcut(const QString& _cut)
 {
     QString cut = rules()->checkShortcut(_cut);
     auto updateShortcut  = [this](const QKeySequence &cut = QKeySequence()) {
         if (_shortcut == cut)
             return;
         _shortcut = cut;
         setShortcutInternal();
     };
     if (cut.isEmpty()) {
         updateShortcut();
         return;
     }
     if (cut == shortcut().toString()) {
         return; // no change
     }
 // Format:
 // base+(abcdef)<space>base+(abcdef)
 // E.g. Alt+Ctrl+(ABCDEF);Meta+X,Meta+(ABCDEF)
     if (!cut.contains(QLatin1Char('(')) && !cut.contains(QLatin1Char(')')) && !cut.contains(QLatin1String(" - "))) {
         if (workspace()->shortcutAvailable(cut, this))
             updateShortcut(QKeySequence(cut));
         else
             updateShortcut();
         return;
     }
     QList< QKeySequence > keys;
     QStringList groups = cut.split(QStringLiteral(" - "));
     for (QStringList::ConstIterator it = groups.constBegin();
             it != groups.constEnd();
             ++it) {
         QRegExp reg(QStringLiteral("(.*\\+)\\((.*)\\)"));
         if (reg.indexIn(*it) > -1) {
             QString base = reg.cap(1);
             QString list = reg.cap(2);
             for (int i = 0;
                     i < list.length();
                     ++i) {
                 QKeySequence c(base + list[ i ]);
                 if (!c.isEmpty())
                     keys.append(c);
             }
         } else {
             // regexp doesn't match, so it should be a normal shortcut
             QKeySequence c(*it);
             if (!c.isEmpty()) {
                 keys.append(c);
             }
         }
     }
     for (auto it = keys.constBegin();
             it != keys.constEnd();
             ++it) {
         if (_shortcut == *it)   // current one is in the list
             return;
     }
     for (auto it = keys.constBegin();
             it != keys.constEnd();
             ++it) {
         if (workspace()->shortcutAvailable(*it, this)) {
             updateShortcut(*it);
             return;
         }
     }
     updateShortcut();
 }
 
 void AbstractClient::setShortcutInternal()
 {
     updateCaption();
     workspace()->clientShortcutUpdated(this);
 }
 
 void X11Client::setShortcutInternal()
 {
     updateCaption();
 #if 0
     workspace()->clientShortcutUpdated(this);
 #else
     // Workaround for kwin<->kglobalaccel deadlock, when KWin has X grab and the kded
     // kglobalaccel module tries to create the key grab. KWin should preferably grab
     // they keys itself anyway :(.
     QTimer::singleShot(0, this, std::bind(&Workspace::clientShortcutUpdated, workspace(), this));
 #endif
 }
 
 bool Workspace::shortcutAvailable(const QKeySequence &cut, AbstractClient* ignore) const
 {
     if (ignore && cut == ignore->shortcut())
         return true;
 
     if (!KGlobalAccel::getGlobalShortcutsByKey(cut).isEmpty()) {
         return false;
     }
     for (auto it = m_allClients.constBegin();
             it != m_allClients.constEnd();
             ++it) {
         if ((*it) != ignore && (*it)->shortcut() == cut)
             return false;
     }
     return true;
 }
 
 } // namespace
diff --git a/x11client.cpp b/x11client.cpp
index 73491b01b..6e2509d3c 100644
--- a/x11client.cpp
+++ b/x11client.cpp
@@ -1,5048 +1,4991 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 // own
 #include "x11client.h"
 // kwin
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "atoms.h"
 #include "client_machine.h"
 #include "composite.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "geometrytip.h"
 #include "group.h"
 #include "netinfo.h"
 #include "screens.h"
 #include "shadow.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "workspace.h"
 #include "screenedge.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/decoratedclient.h"
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecoratedClient>
 // KDE
 #include <KLocalizedString>
 #include <KStartupInfo>
 #include <KWindowSystem>
 #include <KColorScheme>
 // Qt
 #include <QApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QMouseEvent>
 #include <QProcess>
 // xcb
 #include <xcb/xcb_icccm.h>
 // system
 #include <unistd.h>
 // c++
 #include <csignal>
 
 // Put all externs before the namespace statement to allow the linker
 // to resolve them properly
 
 namespace KWin
 {
 
 const long ClientWinMask = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
                            XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
                            XCB_EVENT_MASK_KEYMAP_STATE |
                            XCB_EVENT_MASK_BUTTON_MOTION |
                            XCB_EVENT_MASK_POINTER_MOTION | // need this, too!
                            XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
                            XCB_EVENT_MASK_FOCUS_CHANGE |
                            XCB_EVENT_MASK_EXPOSURE |
                            XCB_EVENT_MASK_STRUCTURE_NOTIFY |
                            XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
 
 // window types that are supported as normal windows (i.e. KWin actually manages them)
 const NET::WindowTypes SUPPORTED_MANAGED_WINDOW_TYPES_MASK = NET::NormalMask | NET::DesktopMask | NET::DockMask
         | NET::ToolbarMask | NET::MenuMask | NET::DialogMask /*| NET::OverrideMask*/ | NET::TopMenuMask
         | NET::UtilityMask | NET::SplashMask | NET::NotificationMask | NET::OnScreenDisplayMask
         | NET::CriticalNotificationMask;
 
 // Creating a client:
 //  - only by calling Workspace::createClient()
 //      - it creates a new client and calls manage() for it
 //
 // Destroying a client:
 //  - destroyClient() - only when the window itself has been destroyed
 //      - releaseWindow() - the window is kept, only the client itself is destroyed
 
 /**
  * \class Client x11client.h
  * \brief The Client class encapsulates a window decoration frame.
  */
 
 /**
  * This ctor is "dumb" - it only initializes data. All the real initialization
  * is done in manage().
  */
 X11Client::X11Client()
     : AbstractClient()
     , m_client()
     , m_wrapper()
     , m_frame()
     , m_activityUpdatesBlocked(false)
     , m_blockedActivityUpdatesRequireTransients(false)
     , m_moveResizeGrabWindow()
     , move_resize_has_keyboard_grab(false)
     , m_managed(false)
     , m_transientForId(XCB_WINDOW_NONE)
     , m_originalTransientForId(XCB_WINDOW_NONE)
     , shade_below(nullptr)
     , m_motif(atoms->motif_wm_hints)
     , blocks_compositing(false)
-    , shadeHoverTimer(nullptr)
     , m_colormap(XCB_COLORMAP_NONE)
     , in_group(nullptr)
     , ping_timer(nullptr)
     , m_killHelperPID(0)
     , m_pingTimestamp(XCB_TIME_CURRENT_TIME)
     , m_userTime(XCB_TIME_CURRENT_TIME)   // Not known yet
     , allowed_actions()
     , shade_geometry_change(false)
     , sm_stacking_order(-1)
     , activitiesDefined(false)
     , sessionActivityOverride(false)
     , needsXWindowMove(false)
     , m_decoInputExtent()
     , m_focusOutTimer(nullptr)
 {
     // TODO: Do all as initialization
     m_syncRequest.counter = m_syncRequest.alarm = XCB_NONE;
     m_syncRequest.timeout = m_syncRequest.failsafeTimeout = nullptr;
     m_syncRequest.lastTimestamp = xTime();
     m_syncRequest.isPending = false;
 
     // Set the initial mapping state
     mapping_state = Withdrawn;
 
     info = nullptr;
 
-    shade_mode = ShadeNone;
     deleting = false;
     m_fullscreenMode = FullScreenNone;
     hidden = false;
     noborder = false;
     app_noborder = false;
     ignore_focus_stealing = false;
     check_active_modal = false;
 
     max_mode = MaximizeRestore;
 
     //Client to workspace connections require that each
     //client constructed be connected to the workspace wrapper
 
     m_frameGeometry = QRect(0, 0, 100, 100);   // So that decorations don't start with size being (0,0)
 
     connect(clientMachine(), &ClientMachine::localhostChanged, this, &X11Client::updateCaption);
     connect(options, &Options::condensedTitleChanged, this, &X11Client::updateCaption);
 
     connect(this, &X11Client::moveResizeCursorChanged, this, [this] (CursorShape cursor) {
         xcb_cursor_t nativeCursor = Cursors::self()->mouse()->x11Cursor(cursor);
         m_frame.defineCursor(nativeCursor);
         if (m_decoInputExtent.isValid())
             m_decoInputExtent.defineCursor(nativeCursor);
         if (isMoveResize()) {
             // changing window attributes doesn't change cursor if there's pointer grab active
             xcb_change_active_pointer_grab(connection(), nativeCursor, xTime(),
                 XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW);
         }
     });
 
     // SELI TODO: Initialize xsizehints??
 }
 
 /**
  * "Dumb" destructor.
  */
 X11Client::~X11Client()
 {
     if (m_killHelperPID && !::kill(m_killHelperPID, 0)) { // means the process is alive
         ::kill(m_killHelperPID, SIGTERM);
         m_killHelperPID = 0;
     }
     if (m_syncRequest.alarm != XCB_NONE) {
         xcb_sync_destroy_alarm(connection(), m_syncRequest.alarm);
     }
     Q_ASSERT(!isMoveResize());
     Q_ASSERT(m_client == XCB_WINDOW_NONE);
     Q_ASSERT(m_wrapper == XCB_WINDOW_NONE);
     Q_ASSERT(m_frame == XCB_WINDOW_NONE);
     Q_ASSERT(!check_active_modal);
     for (auto it = m_connections.constBegin(); it != m_connections.constEnd(); ++it) {
         disconnect(*it);
     }
 }
 
 // Use destroyClient() or releaseWindow(), Client instances cannot be deleted directly
 void X11Client::deleteClient(X11Client *c)
 {
     delete c;
 }
 
 /**
  * Releases the window. The client has done its job and the window is still existing.
  */
 void X11Client::releaseWindow(bool on_shutdown)
 {
     Q_ASSERT(!deleting);
     deleting = true;
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox->isDisplayed() && tabBox->currentClient() == this) {
         tabBox->nextPrev(true);
     }
 #endif
     destroyWindowManagementInterface();
     Deleted* del = nullptr;
     if (!on_shutdown) {
         del = Deleted::create(this);
     }
     if (isMoveResize())
         emit clientFinishUserMovedResized(this);
     emit windowClosed(this, del);
     finishCompositing();
     RuleBook::self()->discardUsed(this, true);   // Remove ForceTemporarily rules
     StackingUpdatesBlocker blocker(workspace());
     if (isMoveResize())
         leaveMoveResize();
     finishWindowRules();
     blockGeometryUpdates();
     if (isOnCurrentDesktop() && isShown(true))
         addWorkspaceRepaint(visibleRect());
     // Grab X during the release to make removing of properties, setting to withdrawn state
     // and repareting to root an atomic operation (https://lists.kde.org/?l=kde-devel&m=116448102901184&w=2)
     grabXServer();
     exportMappingState(XCB_ICCCM_WM_STATE_WITHDRAWN);
     setModal(false);   // Otherwise its mainwindow wouldn't get focus
     hidden = true; // So that it's not considered visible anymore (can't use hideClient(), it would set flags)
     if (!on_shutdown)
         workspace()->clientHidden(this);
     m_frame.unmap();  // Destroying decoration would cause ugly visual effect
     destroyDecoration();
     cleanGrouping();
     if (!on_shutdown) {
         workspace()->removeClient(this);
         // Only when the window is being unmapped, not when closing down KWin (NETWM sections 5.5,5.7)
         info->setDesktop(0);
         info->setState(NET::States(), info->state());  // Reset all state flags
     }
     xcb_connection_t *c = connection();
     m_client.deleteProperty(atoms->kde_net_wm_user_creation_time);
     m_client.deleteProperty(atoms->net_frame_extents);
     m_client.deleteProperty(atoms->kde_net_wm_frame_strut);
     m_client.reparent(rootWindow(), m_bufferGeometry.x(), m_bufferGeometry.y());
     xcb_change_save_set(c, XCB_SET_MODE_DELETE, m_client);
     m_client.selectInput(XCB_EVENT_MASK_NO_EVENT);
     if (on_shutdown)
         // Map the window, so it can be found after another WM is started
         m_client.map();
     // TODO: Preserve minimized, shaded etc. state?
     else // Make sure it's not mapped if the app unmapped it (#65279). The app
         // may do map+unmap before we initially map the window by calling rawShow() from manage().
         m_client.unmap();
     m_client.reset();
     m_wrapper.reset();
     m_frame.reset();
     unblockGeometryUpdates(); // Don't use GeometryUpdatesBlocker, it would now set the geometry
     if (!on_shutdown) {
         disownDataPassedToDeleted();
         del->unrefWindow();
     }
     deleteClient(this);
     ungrabXServer();
 }
 
 /**
  * Like releaseWindow(), but this one is called when the window has been already destroyed
  * (E.g. The application closed it)
  */
 void X11Client::destroyClient()
 {
     Q_ASSERT(!deleting);
     deleting = true;
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox && tabBox->isDisplayed() && tabBox->currentClient() == this) {
         tabBox->nextPrev(true);
     }
 #endif
     destroyWindowManagementInterface();
     Deleted* del = Deleted::create(this);
     if (isMoveResize())
         emit clientFinishUserMovedResized(this);
     emit windowClosed(this, del);
     finishCompositing(ReleaseReason::Destroyed);
     RuleBook::self()->discardUsed(this, true);   // Remove ForceTemporarily rules
     StackingUpdatesBlocker blocker(workspace());
     if (isMoveResize())
         leaveMoveResize();
     finishWindowRules();
     blockGeometryUpdates();
     if (isOnCurrentDesktop() && isShown(true))
         addWorkspaceRepaint(visibleRect());
     setModal(false);
     hidden = true; // So that it's not considered visible anymore
     workspace()->clientHidden(this);
     destroyDecoration();
     cleanGrouping();
     workspace()->removeClient(this);
     m_client.reset(); // invalidate
     m_wrapper.reset();
     m_frame.reset();
     unblockGeometryUpdates(); // Don't use GeometryUpdatesBlocker, it would now set the geometry
     disownDataPassedToDeleted();
     del->unrefWindow();
     deleteClient(this);
 }
 
 /**
  * Manages the clients. This means handling the very first maprequest:
  * reparenting, initial geometry, initial state, placement, etc.
  * Returns false if KWin is not going to manage this window.
  */
 bool X11Client::manage(xcb_window_t w, bool isMapped)
 {
     StackingUpdatesBlocker stacking_blocker(workspace());
 
     Xcb::WindowAttributes attr(w);
     Xcb::WindowGeometry windowGeometry(w);
     if (attr.isNull() || windowGeometry.isNull()) {
         return false;
     }
 
     // From this place on, manage() must not return false
     blockGeometryUpdates();
     setPendingGeometryUpdate(PendingGeometryForced); // Force update when finishing with geometry changes
 
     embedClient(w, attr->visual, attr->colormap, windowGeometry->depth);
 
     m_visual = attr->visual;
     bit_depth = windowGeometry->depth;
 
     // SELI TODO: Order all these things in some sane manner
 
     const NET::Properties properties =
         NET::WMDesktop |
         NET::WMState |
         NET::WMWindowType |
         NET::WMStrut |
         NET::WMName |
         NET::WMIconGeometry |
         NET::WMIcon |
         NET::WMPid |
         NET::WMIconName;
     const NET::Properties2 properties2 =
         NET::WM2BlockCompositing |
         NET::WM2WindowClass |
         NET::WM2WindowRole |
         NET::WM2UserTime |
         NET::WM2StartupId |
         NET::WM2ExtendedStrut |
         NET::WM2Opacity |
         NET::WM2FullscreenMonitors |
         NET::WM2FrameOverlap |
         NET::WM2GroupLeader |
         NET::WM2Urgency |
         NET::WM2Input |
         NET::WM2Protocols |
         NET::WM2InitialMappingState |
         NET::WM2IconPixmap |
         NET::WM2OpaqueRegion |
         NET::WM2DesktopFileName |
         NET::WM2GTKFrameExtents;
 
     auto wmClientLeaderCookie = fetchWmClientLeader();
     auto skipCloseAnimationCookie = fetchSkipCloseAnimation();
     auto showOnScreenEdgeCookie = fetchShowOnScreenEdge();
     auto colorSchemeCookie = fetchColorScheme();
     auto firstInTabBoxCookie = fetchFirstInTabBox();
     auto transientCookie = fetchTransient();
     auto activitiesCookie = fetchActivities();
     auto applicationMenuServiceNameCookie = fetchApplicationMenuServiceName();
     auto applicationMenuObjectPathCookie = fetchApplicationMenuObjectPath();
 
     m_geometryHints.init(window());
     m_motif.init(window());
     info = new WinInfo(this, m_client, rootWindow(), properties, properties2);
 
     if (isDesktop() && bit_depth == 32) {
         // force desktop windows to be opaque. It's a desktop after all, there is no window below
         bit_depth = 24;
     }
 
     // If it's already mapped, ignore hint
     bool init_minimize = !isMapped && (info->initialMappingState() == NET::Iconic);
 
     m_colormap = attr->colormap;
 
     getResourceClass();
     readWmClientLeader(wmClientLeaderCookie);
     getWmClientMachine();
     getSyncCounter();
     // First only read the caption text, so that setupWindowRules() can use it for matching,
     // and only then really set the caption using setCaption(), which checks for duplicates etc.
     // and also relies on rules already existing
     cap_normal = readName();
     setupWindowRules(false);
     setCaption(cap_normal, true);
 
     connect(this, &X11Client::windowClassChanged, this, &X11Client::evaluateWindowRules);
 
     if (Xcb::Extensions::self()->isShapeAvailable())
         xcb_shape_select_input(connection(), window(), true);
     detectShape(window());
     detectNoBorder();
     fetchIconicName();
     setClientFrameExtents(info->gtkFrameExtents());
 
     // Needs to be done before readTransient() because of reading the group
     checkGroup();
     updateUrgency();
     updateAllowedActions(); // Group affects isMinimizable()
 
     setModal((info->state() & NET::Modal) != 0);   // Needs to be valid before handling groups
     readTransientProperty(transientCookie);
     setDesktopFileName(rules()->checkDesktopFile(QByteArray(info->desktopFileName()), true).toUtf8());
     getIcons();
     connect(this, &X11Client::desktopFileNameChanged, this, &X11Client::getIcons);
 
     m_geometryHints.read();
     getMotifHints();
     getWmOpaqueRegion();
     readSkipCloseAnimation(skipCloseAnimationCookie);
 
     // TODO: Try to obey all state information from info->state()
 
     setOriginalSkipTaskbar((info->state() & NET::SkipTaskbar) != 0);
     setSkipPager((info->state() & NET::SkipPager) != 0);
     setSkipSwitcher((info->state() & NET::SkipSwitcher) != 0);
     readFirstInTabBox(firstInTabBoxCookie);
 
     setupCompositing();
 
     KStartupInfoId asn_id;
     KStartupInfoData asn_data;
     bool asn_valid = workspace()->checkStartupNotification(window(), asn_id, asn_data);
 
     // Make sure that the input window is created before we update the stacking order
     updateInputWindow();
 
     workspace()->updateClientLayer(this);
 
     SessionInfo* session = workspace()->takeSessionInfo(this);
     if (session) {
         init_minimize = session->minimized;
         noborder = session->noBorder;
     }
 
     setShortcut(rules()->checkShortcut(session ? session->shortcut : QString(), true));
 
     init_minimize = rules()->checkMinimize(init_minimize, !isMapped);
     noborder = rules()->checkNoBorder(noborder, !isMapped);
 
     readActivities(activitiesCookie);
 
     // Initial desktop placement
     int desk = 0;
     if (session) {
         desk = session->desktop;
         if (session->onAllDesktops)
             desk = NET::OnAllDesktops;
         setOnActivities(session->activities);
     } else {
         // If this window is transient, ensure that it is opened on the
         // same window as its parent.  this is necessary when an application
         // starts up on a different desktop than is currently displayed
         if (isTransient()) {
             auto mainclients = mainClients();
             bool on_current = false;
             bool on_all = false;
             AbstractClient* maincl = nullptr;
             // This is slightly duplicated from Placement::placeOnMainWindow()
             for (auto it = mainclients.constBegin();
                     it != mainclients.constEnd();
                     ++it) {
                 if (mainclients.count() > 1 &&      // A group-transient
                     (*it)->isSpecialWindow() &&     // Don't consider toolbars etc when placing
                     !(info->state() & NET::Modal))  // except when it's modal (blocks specials as well)
                     continue;
                 maincl = *it;
                 if ((*it)->isOnCurrentDesktop())
                     on_current = true;
                 if ((*it)->isOnAllDesktops())
                     on_all = true;
             }
             if (on_all)
                 desk = NET::OnAllDesktops;
             else if (on_current)
                 desk = VirtualDesktopManager::self()->current();
             else if (maincl != nullptr)
                 desk = maincl->desktop();
 
             if (maincl)
                 setOnActivities(maincl->activities());
         } else { // a transient shall appear on its leader and not drag that around
             if (info->desktop())
                 desk = info->desktop(); // Window had the initial desktop property, force it
             if (desktop() == 0 && asn_valid && asn_data.desktop() != 0)
                 desk = asn_data.desktop();
         }
 #ifdef KWIN_BUILD_ACTIVITIES
         if (Activities::self() && !isMapped && !skipTaskbar() && isNormalWindow() && !activitiesDefined) {
             //a new, regular window, when we're not recovering from a crash,
             //and it hasn't got an activity. let's try giving it the current one.
             //TODO: decide whether to keep this before the 4.6 release
             //TODO: if we are keeping it (at least as an option), replace noborder checking
             //with a public API for setting windows to be on all activities.
             //something like KWindowSystem::setOnAllActivities or
             //KActivityConsumer::setOnAllActivities
             setOnActivity(Activities::self()->current(), true);
         }
 #endif
     }
 
     if (desk == 0)   // Assume window wants to be visible on the current desktop
         desk = isDesktop() ? static_cast<int>(NET::OnAllDesktops) : VirtualDesktopManager::self()->current();
     desk = rules()->checkDesktop(desk, !isMapped);
     if (desk != NET::OnAllDesktops)   // Do range check
         desk = qBound(1, desk, static_cast<int>(VirtualDesktopManager::self()->count()));
     setDesktop(desk);
     info->setDesktop(desk);
     workspace()->updateOnAllDesktopsOfTransients(this);   // SELI TODO
     //onAllDesktopsChange(); // Decoration doesn't exist here yet
 
     QString activitiesList;
     activitiesList = rules()->checkActivity(activitiesList, !isMapped);
     if (!activitiesList.isEmpty())
         setOnActivities(activitiesList.split(QStringLiteral(",")));
 
     QRect geom(windowGeometry.rect());
     bool placementDone = false;
 
     if (session)
         geom = session->geometry;
 
     QRect area;
     bool partial_keep_in_area = isMapped || session;
     if (isMapped || session) {
         area = workspace()->clientArea(FullArea, geom.center(), desktop());
         checkOffscreenPosition(&geom, area);
     } else {
         int screen = asn_data.xinerama() == -1 ? screens()->current() : asn_data.xinerama();
         screen = rules()->checkScreen(screen, !isMapped);
         area = workspace()->clientArea(PlacementArea, screens()->geometry(screen).center(), desktop());
     }
 
     if (isDesktop())
         // KWin doesn't manage desktop windows
         placementDone = true;
 
     bool usePosition = false;
     if (isMapped || session || placementDone)
         placementDone = true; // Use geometry
     else if (isTransient() && !isUtility() && !isDialog() && !isSplash())
         usePosition = true;
     else if (isTransient() && !hasNETSupport())
         usePosition = true;
     else if (isDialog() && hasNETSupport()) {
         // If the dialog is actually non-NETWM transient window, don't try to apply placement to it,
         // it breaks with too many things (xmms, display)
         if (mainClients().count() >= 1) {
 #if 1
             // #78082 - Ok, it seems there are after all some cases when an application has a good
             // reason to specify a position for its dialog. Too bad other WMs have never bothered
             // with placement for dialogs, so apps always specify positions for their dialogs,
             // including such silly positions like always centered on the screen or under mouse.
             // Using ignoring requested position in window-specific settings helps, and now
             // there's also _NET_WM_FULL_PLACEMENT.
             usePosition = true;
 #else
             ; // Force using placement policy
 #endif
         } else
             usePosition = true;
     } else if (isSplash())
         ; // Force using placement policy
     else
         usePosition = true;
     if (!rules()->checkIgnoreGeometry(!usePosition, true)) {
         if (m_geometryHints.hasPosition()) {
             placementDone = true;
             // Disobey xinerama placement option for now (#70943)
             area = workspace()->clientArea(PlacementArea, geom.center(), desktop());
         }
     }
 
     if (isMovable() && (geom.x() > area.right() || geom.y() > area.bottom()))
         placementDone = false; // Weird, do not trust.
 
     if (placementDone) {
         QPoint position = geom.topLeft();
         // Session contains the position of the frame geometry before gravitating.
         if (!session) {
             position = clientPosToFramePos(position);
         }
         move(position);
     }
 
     // Create client group if the window will have a decoration
     bool dontKeepInArea = false;
     readColorScheme(colorSchemeCookie);
 
     readApplicationMenuServiceName(applicationMenuServiceNameCookie);
     readApplicationMenuObjectPath(applicationMenuObjectPathCookie);
 
     updateDecoration(false);   // Also gravitates
     // TODO: Is CentralGravity right here, when resizing is done after gravitating?
     const QSize constrainedClientSize = constrainClientSize(geom.size());
     plainResize(rules()->checkSize(clientSizeToFrameSize(constrainedClientSize), !isMapped));
 
     QPoint forced_pos = rules()->checkPosition(invalidPoint, !isMapped);
     if (forced_pos != invalidPoint) {
         move(forced_pos);
         placementDone = true;
         // Don't keep inside workarea if the window has specially configured position
         partial_keep_in_area = true;
         area = workspace()->clientArea(FullArea, geom.center(), desktop());
     }
     if (!placementDone) {
         // Placement needs to be after setting size
         Placement::self()->place(this, area);
         // The client may have been moved to another screen, update placement area.
         area = workspace()->clientArea(PlacementArea, this);
         dontKeepInArea = true;
         placementDone = true;
     }
 
     // bugs #285967, #286146, #183694
     // geometry() now includes the requested size and the decoration and is at the correct screen/position (hopefully)
     // Maximization for oversized windows must happen NOW.
     // If we effectively pass keepInArea(), the window will resizeWithChecks() - i.e. constrained
     // to the combo of all screen MINUS all struts on the edges
     // If only one screen struts, this will affect screens as a side-effect, the window is artificailly shrinked
     // below the screen size and as result no more maximized what breaks KMainWindow's stupid width+1, height+1 hack
     // TODO: get KMainWindow a correct state storage what will allow to store the restore size as well.
 
     if (!session) { // has a better handling of this
         setGeometryRestore(frameGeometry()); // Remember restore geometry
         if (isMaximizable() && (width() >= area.width() || height() >= area.height())) {
             // Window is too large for the screen, maximize in the
             // directions necessary
             const QSize ss = workspace()->clientArea(ScreenArea, area.center(), desktop()).size();
             const QRect fsa = workspace()->clientArea(FullArea, geom.center(), desktop());
             const QSize cs = clientSize();
             int pseudo_max = ((info->state() & NET::MaxVert) ? MaximizeVertical : 0) |
                              ((info->state() & NET::MaxHoriz) ? MaximizeHorizontal : 0);
             if (width() >= area.width())
                 pseudo_max |=  MaximizeHorizontal;
             if (height() >= area.height())
                 pseudo_max |=  MaximizeVertical;
 
             // heuristics:
             // if decorated client is smaller than the entire screen, the user might want to move it around (multiscreen)
             // in this case, if the decorated client is bigger than the screen (+1), we don't take this as an
             // attempt for maximization, but just constrain the size (the window simply wants to be bigger)
             // NOTICE
             // i intended a second check on cs < area.size() ("the managed client ("minus border") is smaller
             // than the workspace") but gtk / gimp seems to store it's size including the decoration,
             // thus a former maximized window wil become non-maximized
             bool keepInFsArea = false;
             if (width() < fsa.width() && (cs.width() > ss.width()+1)) {
                 pseudo_max &= ~MaximizeHorizontal;
                 keepInFsArea = true;
             }
             if (height() < fsa.height() && (cs.height() > ss.height()+1)) {
                 pseudo_max &= ~MaximizeVertical;
                 keepInFsArea = true;
             }
 
             if (pseudo_max != MaximizeRestore) {
                 maximize((MaximizeMode)pseudo_max);
                 // from now on, care about maxmode, since the maximization call will override mode for fix aspects
                 dontKeepInArea |= (max_mode == MaximizeFull);
                 QRect savedGeometry; // Use placement when unmaximizing ...
                 if (!(max_mode & MaximizeVertical)) {
                     savedGeometry.setY(y());   // ...but only for horizontal direction
                     savedGeometry.setHeight(height());
                 }
                 if (!(max_mode & MaximizeHorizontal)) {
                     savedGeometry.setX(x());   // ...but only for vertical direction
                     savedGeometry.setWidth(width());
                 }
                 setGeometryRestore(savedGeometry);
             }
             if (keepInFsArea)
                 keepInArea(fsa, partial_keep_in_area);
         }
     }
 
     if ((!isSpecialWindow() || isToolbar()) && isMovable() && !dontKeepInArea)
         keepInArea(area, partial_keep_in_area);
 
     updateShape();
 
     // CT: Extra check for stupid jdk 1.3.1. But should make sense in general
     // if client has initial state set to Iconic and is transient with a parent
     // window that is not Iconic, set init_state to Normal
     if (init_minimize && isTransient()) {
         auto mainclients = mainClients();
         for (auto it = mainclients.constBegin();
                 it != mainclients.constEnd();
                 ++it)
             if ((*it)->isShown(true))
                 init_minimize = false; // SELI TODO: Even e.g. for NET::Utility?
     }
     // If a dialog is shown for minimized window, minimize it too
     if (!init_minimize && isTransient() && mainClients().count() > 0 &&
             workspace()->sessionManager()->state() != SessionState::Saving) {
         bool visible_parent = false;
         // Use allMainClients(), to include also main clients of group transients
         // that have been optimized out in X11Client::checkGroupTransients()
         auto mainclients = allMainClients();
         for (auto it = mainclients.constBegin();
                 it != mainclients.constEnd();
                 ++it)
             if ((*it)->isShown(true))
                 visible_parent = true;
         if (!visible_parent) {
             init_minimize = true;
             demandAttention();
         }
     }
 
     if (init_minimize)
         minimize(true);   // No animation
 
     // Other settings from the previous session
     if (session) {
         // Session restored windows are not considered to be new windows WRT rules,
         // I.e. obey only forcing rules
         setKeepAbove(session->keepAbove);
         setKeepBelow(session->keepBelow);
         setOriginalSkipTaskbar(session->skipTaskbar);
         setSkipPager(session->skipPager);
         setSkipSwitcher(session->skipSwitcher);
         setShade(session->shaded ? ShadeNormal : ShadeNone);
         setOpacity(session->opacity);
         setGeometryRestore(session->restore);
         if (session->maximized != MaximizeRestore) {
             maximize(MaximizeMode(session->maximized));
         }
         if (session->fullscreen != FullScreenNone) {
             setFullScreen(true, false);
             geom_fs_restore = session->fsrestore;
         }
         QRect checkedGeometryRestore = geometryRestore();
         checkOffscreenPosition(&checkedGeometryRestore, area);
         checkOffscreenPosition(&geom_fs_restore, area);
         setGeometryRestore(checkedGeometryRestore);
     } else {
         // Window may want to be maximized
         // done after checking that the window isn't larger than the workarea, so that
         // the restore geometry from the checks above takes precedence, and window
         // isn't restored larger than the workarea
         MaximizeMode maxmode = static_cast<MaximizeMode>(
                                    ((info->state() & NET::MaxVert) ? MaximizeVertical : 0) |
                                    ((info->state() & NET::MaxHoriz) ? MaximizeHorizontal : 0));
         MaximizeMode forced_maxmode = rules()->checkMaximize(maxmode, !isMapped);
 
         // Either hints were set to maximize, or is forced to maximize,
         // or is forced to non-maximize and hints were set to maximize
         if (forced_maxmode != MaximizeRestore || maxmode != MaximizeRestore)
             maximize(forced_maxmode);
 
         // Read other initial states
         setShade(rules()->checkShade(info->state() & NET::Shaded ? ShadeNormal : ShadeNone, !isMapped));
         setKeepAbove(rules()->checkKeepAbove(info->state() & NET::KeepAbove, !isMapped));
         setKeepBelow(rules()->checkKeepBelow(info->state() & NET::KeepBelow, !isMapped));
         setOriginalSkipTaskbar(rules()->checkSkipTaskbar(info->state() & NET::SkipTaskbar, !isMapped));
         setSkipPager(rules()->checkSkipPager(info->state() & NET::SkipPager, !isMapped));
         setSkipSwitcher(rules()->checkSkipSwitcher(info->state() & NET::SkipSwitcher, !isMapped));
         if (info->state() & NET::DemandsAttention)
             demandAttention();
         if (info->state() & NET::Modal)
             setModal(true);
 
         setFullScreen(rules()->checkFullScreen(info->state() & NET::FullScreen, !isMapped), false);
     }
 
     updateAllowedActions(true);
 
     // Set initial user time directly
     m_userTime = readUserTimeMapTimestamp(asn_valid ? &asn_id : nullptr, asn_valid ? &asn_data : nullptr, session);
     group()->updateUserTime(m_userTime);   // And do what X11Client::updateUserTime() does
 
     // This should avoid flicker, because real restacking is done
     // only after manage() finishes because of blocking, but the window is shown sooner
     m_frame.lower();
     if (session && session->stackingOrder != -1) {
         sm_stacking_order = session->stackingOrder;
         workspace()->restoreSessionStackingOrder(this);
     }
 
     if (compositing())
         // Sending ConfigureNotify is done when setting mapping state below,
         // Getting the first sync response means window is ready for compositing
         sendSyncRequest();
     else
         ready_for_painting = true; // set to true in case compositing is turned on later. bug #160393
 
     if (isShown(true)) {
         bool allow;
         if (session)
             allow = session->active &&
                     (!workspace()->wasUserInteraction() || workspace()->activeClient() == nullptr ||
                      workspace()->activeClient()->isDesktop());
         else
             allow = workspace()->allowClientActivation(this, userTime(), false);
 
         const bool isSessionSaving = workspace()->sessionManager()->state() == SessionState::Saving;
 
         // If session saving, force showing new windows (i.e. "save file?" dialogs etc.)
         // also force if activation is allowed
         if( !isOnCurrentDesktop() && !isMapped && !session && ( allow || isSessionSaving ))
             VirtualDesktopManager::self()->setCurrent( desktop());
 
         // If the window is on an inactive activity during session saving, temporarily force it to show.
         if( !isMapped && !session && isSessionSaving && !isOnCurrentActivity()) {
             setSessionActivityOverride( true );
             foreach( AbstractClient* c, mainClients()) {
                 if (X11Client *mc = dynamic_cast<X11Client *>(c)) {
                     mc->setSessionActivityOverride(true);
                 }
             }
         }
 
         if (isOnCurrentDesktop() && !isMapped && !allow && (!session || session->stackingOrder < 0))
             workspace()->restackClientUnderActive(this);
 
         updateVisibility();
 
         if (!isMapped) {
             if (allow && isOnCurrentDesktop()) {
                 if (!isSpecialWindow())
                     if (options->focusPolicyIsReasonable() && wantsTabFocus())
                         workspace()->requestFocus(this);
             } else if (!session && !isSpecialWindow())
                 demandAttention();
         }
     } else
         updateVisibility();
     Q_ASSERT(mapping_state != Withdrawn);
     m_managed = true;
     blockGeometryUpdates(false);
 
     if (m_userTime == XCB_TIME_CURRENT_TIME || m_userTime == -1U) {
         // No known user time, set something old
         m_userTime = xTime() - 1000000;
         if (m_userTime == XCB_TIME_CURRENT_TIME || m_userTime == -1U)   // Let's be paranoid
             m_userTime = xTime() - 1000000 + 10;
     }
 
     //sendSyntheticConfigureNotify(); // Done when setting mapping state
 
     delete session;
 
     discardTemporaryRules();
     applyWindowRules(); // Just in case
     RuleBook::self()->discardUsed(this, false);   // Remove ApplyNow rules
     updateWindowRules(Rules::All); // Was blocked while !isManaged()
 
     setBlockingCompositing(info->isBlockingCompositing());
     readShowOnScreenEdge(showOnScreenEdgeCookie);
 
     // Forward all opacity values to the frame in case there'll be other CM running.
     connect(Compositor::self(), &Compositor::compositingToggled, this,
         [this](bool active) {
             if (active) {
                 return;
             }
             if (opacity() == 1.0) {
                 return;
             }
             NETWinInfo info(connection(), frameId(), rootWindow(), NET::Properties(), NET::Properties2());
             info.setOpacity(static_cast<unsigned long>(opacity() * 0xffffffff));
         }
     );
 
     // TODO: there's a small problem here - isManaged() depends on the mapping state,
     // but this client is not yet in Workspace's client list at this point, will
     // be only done in addClient()
     emit clientManaging(this);
     return true;
 }
 
 // Called only from manage()
 void X11Client::embedClient(xcb_window_t w, xcb_visualid_t visualid, xcb_colormap_t colormap, uint8_t depth)
 {
     Q_ASSERT(m_client == XCB_WINDOW_NONE);
     Q_ASSERT(frameId() == XCB_WINDOW_NONE);
     Q_ASSERT(m_wrapper == XCB_WINDOW_NONE);
     m_client.reset(w, false);
 
     const uint32_t zero_value = 0;
 
     xcb_connection_t *conn = connection();
 
     // We don't want the window to be destroyed when we quit
     xcb_change_save_set(conn, XCB_SET_MODE_INSERT, m_client);
 
     m_client.selectInput(zero_value);
     m_client.unmap();
     m_client.setBorderWidth(zero_value);
 
     // Note: These values must match the order in the xcb_cw_t enum
     const uint32_t cw_values[] = {
         0,                                // back_pixmap
         0,                                // border_pixel
         colormap,                    // colormap
         Cursors::self()->mouse()->x11Cursor(Qt::ArrowCursor)
     };
 
     const uint32_t cw_mask = XCB_CW_BACK_PIXMAP | XCB_CW_BORDER_PIXEL |
                              XCB_CW_COLORMAP | XCB_CW_CURSOR;
 
     const uint32_t common_event_mask = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
                                        XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
                                        XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
                                        XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_POINTER_MOTION |
                                        XCB_EVENT_MASK_KEYMAP_STATE |
                                        XCB_EVENT_MASK_FOCUS_CHANGE |
                                        XCB_EVENT_MASK_EXPOSURE |
                                        XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
 
     const uint32_t frame_event_mask   = common_event_mask | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_VISIBILITY_CHANGE;
     const uint32_t wrapper_event_mask = common_event_mask | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY;
 
     const uint32_t client_event_mask = XCB_EVENT_MASK_FOCUS_CHANGE | XCB_EVENT_MASK_PROPERTY_CHANGE |
                                        XCB_EVENT_MASK_COLOR_MAP_CHANGE |
                                        XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW |
                                        XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
 
     // Create the frame window
     xcb_window_t frame = xcb_generate_id(conn);
     xcb_create_window(conn, depth, frame, rootWindow(), 0, 0, 1, 1, 0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT, visualid, cw_mask, cw_values);
     m_frame.reset(frame);
 
     setWindowHandles(m_client);
 
     // Create the wrapper window
     xcb_window_t wrapperId = xcb_generate_id(conn);
     xcb_create_window(conn, depth, wrapperId, frame, 0, 0, 1, 1, 0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT, visualid, cw_mask, cw_values);
     m_wrapper.reset(wrapperId);
 
     m_client.reparent(m_wrapper);
 
     // We could specify the event masks when we create the windows, but the original
     // Xlib code didn't.  Let's preserve that behavior here for now so we don't end up
     // receiving any unexpected events from the wrapper creation or the reparenting.
     m_frame.selectInput(frame_event_mask);
     m_wrapper.selectInput(wrapper_event_mask);
     m_client.selectInput(client_event_mask);
 
     updateMouseGrab();
 }
 
 void X11Client::updateInputWindow()
 {
     if (!Xcb::Extensions::self()->isShapeInputAvailable())
         return;
 
     QRegion region;
 
     if (!noBorder() && isDecorated()) {
         const QMargins &r = decoration()->resizeOnlyBorders();
         const int left   = r.left();
         const int top    = r.top();
         const int right  = r.right();
         const int bottom = r.bottom();
         if (left != 0 || top != 0 || right != 0 || bottom != 0) {
             region = QRegion(-left,
                              -top,
                              decoration()->size().width() + left + right,
                              decoration()->size().height() + top + bottom);
             region = region.subtracted(decoration()->rect());
         }
     }
 
     if (region.isEmpty()) {
         m_decoInputExtent.reset();
         return;
     }
 
     QRect bounds = region.boundingRect();
     input_offset = bounds.topLeft();
 
     // Move the bounding rect to screen coordinates
     bounds.translate(frameGeometry().topLeft());
 
     // Move the region to input window coordinates
     region.translate(-input_offset);
 
     if (!m_decoInputExtent.isValid()) {
         const uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
         const uint32_t values[] = {true,
             XCB_EVENT_MASK_ENTER_WINDOW   |
             XCB_EVENT_MASK_LEAVE_WINDOW   |
             XCB_EVENT_MASK_BUTTON_PRESS   |
             XCB_EVENT_MASK_BUTTON_RELEASE |
             XCB_EVENT_MASK_POINTER_MOTION
         };
         m_decoInputExtent.create(bounds, XCB_WINDOW_CLASS_INPUT_ONLY, mask, values);
         if (mapping_state == Mapped)
             m_decoInputExtent.map();
     } else {
         m_decoInputExtent.setGeometry(bounds);
     }
 
     const QVector<xcb_rectangle_t> rects = Xcb::regionToRects(region);
     xcb_shape_rectangles(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_CLIP_ORDERING_UNSORTED,
                          m_decoInputExtent, 0, 0, rects.count(), rects.constData());
 }
 
 void X11Client::updateDecoration(bool check_workspace_pos, bool force)
 {
     if (!force &&
             ((!isDecorated() && noBorder()) || (isDecorated() && !noBorder())))
         return;
     QRect oldgeom = frameGeometry();
     QRect oldClientGeom = oldgeom.adjusted(borderLeft(), borderTop(), -borderRight(), -borderBottom());
     blockGeometryUpdates(true);
     if (force)
         destroyDecoration();
     if (!noBorder()) {
         createDecoration(oldgeom);
     } else
         destroyDecoration();
     updateShadow();
     if (check_workspace_pos)
         checkWorkspacePosition(oldgeom, -2, oldClientGeom);
     updateInputWindow();
     blockGeometryUpdates(false);
     updateFrameExtents();
 }
 
 void X11Client::createDecoration(const QRect& oldgeom)
 {
     KDecoration2::Decoration *decoration = Decoration::DecorationBridge::self()->createDecoration(this);
     if (decoration) {
         QMetaObject::invokeMethod(decoration, "update", Qt::QueuedConnection);
         connect(decoration, &KDecoration2::Decoration::shadowChanged, this, &Toplevel::updateShadow);
         connect(decoration, &KDecoration2::Decoration::resizeOnlyBordersChanged, this, &X11Client::updateInputWindow);
         connect(decoration, &KDecoration2::Decoration::bordersChanged, this,
             [this]() {
                 updateFrameExtents();
                 GeometryUpdatesBlocker blocker(this);
                 // TODO: this is obviously idempotent
                 // calculateGravitation(true) would have to operate on the old border sizes
 //                 move(calculateGravitation(true));
 //                 move(calculateGravitation(false));
                 QRect oldgeom = frameGeometry();
                 plainResize(adjustedSize(), ForceGeometrySet);
                 if (!isShade())
                     checkWorkspacePosition(oldgeom);
                 emit geometryShapeChanged(this, oldgeom);
             }
         );
         connect(decoratedClient()->decoratedClient(), &KDecoration2::DecoratedClient::widthChanged, this, &X11Client::updateInputWindow);
         connect(decoratedClient()->decoratedClient(), &KDecoration2::DecoratedClient::heightChanged, this, &X11Client::updateInputWindow);
     }
     setDecoration(decoration);
 
     move(calculateGravitation(false));
     plainResize(adjustedSize(), ForceGeometrySet);
     if (Compositor::compositing()) {
         discardWindowPixmap();
     }
     emit geometryShapeChanged(this, oldgeom);
 }
 
 void X11Client::destroyDecoration()
 {
     QRect oldgeom = frameGeometry();
     if (isDecorated()) {
         QPoint grav = calculateGravitation(true);
         AbstractClient::destroyDecoration();
         plainResize(adjustedSize(), ForceGeometrySet);
         move(grav);
         if (compositing())
             discardWindowPixmap();
         if (!deleting) {
             emit geometryShapeChanged(this, oldgeom);
         }
     }
     m_decoInputExtent.reset();
 }
 
 void X11Client::layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const
 {
     if (!isDecorated()) {
         return;
     }
     QRect r = decoration()->rect();
 
     NETStrut strut = info->frameOverlap();
 
     // Ignore the overlap strut when compositing is disabled
     if (!compositing())
         strut.left = strut.top = strut.right = strut.bottom = 0;
     else if (strut.left == -1 && strut.top == -1 && strut.right == -1 && strut.bottom == -1) {
         top = QRect(r.x(), r.y(), r.width(), r.height() / 3);
         left = QRect(r.x(), r.y() + top.height(), width() / 2, r.height() / 3);
         right = QRect(r.x() + left.width(), r.y() + top.height(), r.width() - left.width(), left.height());
         bottom = QRect(r.x(), r.y() + top.height() + left.height(), r.width(), r.height() - left.height() - top.height());
         return;
     }
 
     top = QRect(r.x(), r.y(), r.width(), borderTop() + strut.top);
     bottom = QRect(r.x(), r.y() + r.height() - borderBottom() - strut.bottom,
                    r.width(), borderBottom() + strut.bottom);
     left = QRect(r.x(), r.y() + top.height(),
                  borderLeft() + strut.left, r.height() - top.height() - bottom.height());
     right = QRect(r.x() + r.width() - borderRight() - strut.right, r.y() + top.height(),
                   borderRight() + strut.right, r.height() - top.height() - bottom.height());
 }
 
 QRect X11Client::transparentRect() const
 {
     if (isShade())
         return QRect();
 
     NETStrut strut = info->frameOverlap();
     // Ignore the strut when compositing is disabled or the decoration doesn't support it
     if (!compositing())
         strut.left = strut.top = strut.right = strut.bottom = 0;
     else if (strut.left == -1 && strut.top == -1 && strut.right == -1 && strut.bottom == -1)
         return QRect();
 
     const QRect r = QRect(clientPos(), clientSize())
                     .adjusted(strut.left, strut.top, -strut.right, -strut.bottom);
     if (r.isValid())
         return r;
 
     return QRect();
 }
 
 void X11Client::detectNoBorder()
 {
     if (shape()) {
         noborder = true;
         app_noborder = true;
         return;
     }
     switch(windowType()) {
     case NET::Desktop :
     case NET::Dock :
     case NET::TopMenu :
     case NET::Splash :
     case NET::Notification :
     case NET::OnScreenDisplay :
     case NET::CriticalNotification :
         noborder = true;
         app_noborder = true;
         break;
     case NET::Unknown :
     case NET::Normal :
     case NET::Toolbar :
     case NET::Menu :
     case NET::Dialog :
     case NET::Utility :
         noborder = false;
         break;
     default:
         abort();
     }
     // NET::Override is some strange beast without clear definition, usually
     // just meaning "noborder", so let's treat it only as such flag, and ignore it as
     // a window type otherwise (SUPPORTED_WINDOW_TYPES_MASK doesn't include it)
     if (info->windowType(NET::OverrideMask) == NET::Override) {
         noborder = true;
         app_noborder = true;
     }
 }
 
 void X11Client::updateFrameExtents()
 {
     NETStrut strut;
     strut.left = borderLeft();
     strut.right = borderRight();
     strut.top = borderTop();
     strut.bottom = borderBottom();
     info->setFrameExtents(strut);
 }
 
 void X11Client::setClientFrameExtents(const NETStrut &strut)
 {
     const QMargins clientFrameExtents(strut.left, strut.top, strut.right, strut.bottom);
     if (m_clientFrameExtents == clientFrameExtents) {
         return;
     }
 
     const bool wasClientSideDecorated = isClientSideDecorated();
     m_clientFrameExtents = clientFrameExtents;
 
     // We should resize the client when its custom frame extents are changed so
     // the logical bounds remain the same. This however means that we will send
     // several configure requests to the application upon restoring it from the
     // maximized or fullscreen state. Notice that a client-side decorated client
     // cannot be shaded, therefore it's okay not to use the adjusted size here.
     setFrameGeometry(frameGeometry());
 
     if (wasClientSideDecorated != isClientSideDecorated()) {
         emit clientSideDecoratedChanged();
     }
 
     // This will invalidate the window quads cache.
     emit geometryShapeChanged(this, frameGeometry());
 }
 
 /**
  * Resizes the decoration, and makes sure the decoration widget gets resize event
  * even if the size hasn't changed. This is needed to make sure the decoration
  * re-layouts (e.g. when maximization state changes,
  * the decoration may alter some borders, but the actual size
  * of the decoration stays the same).
  */
 void X11Client::resizeDecoration()
 {
     triggerDecorationRepaint();
     updateInputWindow();
 }
 
 bool X11Client::userNoBorder() const
 {
     return noborder;
 }
 
 bool X11Client::isFullScreenable() const
 {
     if (!rules()->checkFullScreen(true)) {
         return false;
     }
     if (rules()->checkStrictGeometry(true)) {
         // check geometry constraints (rule to obey is set)
         const QRect fullScreenArea = workspace()->clientArea(FullScreenArea, this);
         const QSize constrainedClientSize = constrainClientSize(fullScreenArea.size());
         if (rules()->checkSize(constrainedClientSize) != fullScreenArea.size()) {
             return false; // the app wouldn't fit exactly fullscreen geometry due to its strict geometry requirements
         }
     }
     // don't check size constrains - some apps request fullscreen despite requesting fixed size
     return !isSpecialWindow(); // also better disallow only weird types to go fullscreen
 }
 
 bool X11Client::noBorder() const
 {
     return userNoBorder() || isFullScreen();
 }
 
 bool X11Client::userCanSetNoBorder() const
 {
     // Client-side decorations and server-side decorations are mutually exclusive.
     if (isClientSideDecorated()) {
         return false;
     }
 
     return !isFullScreen() && !isShade();
 }
 
 void X11Client::setNoBorder(bool set)
 {
     if (!userCanSetNoBorder())
         return;
     set = rules()->checkNoBorder(set);
     if (noborder == set)
         return;
     noborder = set;
     updateDecoration(true, false);
     updateWindowRules(Rules::NoBorder);
 }
 
 void X11Client::checkNoBorder()
 {
     setNoBorder(app_noborder);
 }
 
 bool X11Client::wantsShadowToBeRendered() const
 {
     return !isFullScreen() && maximizeMode() != MaximizeFull;
 }
 
 void X11Client::updateShape()
 {
     if (shape()) {
         // Workaround for #19644 - Shaped windows shouldn't have decoration
         if (!app_noborder) {
             // Only when shape is detected for the first time, still let the user to override
             app_noborder = true;
             noborder = rules()->checkNoBorder(true);
             updateDecoration(true);
         }
         if (noBorder()) {
             xcb_shape_combine(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING, XCB_SHAPE_SK_BOUNDING,
                               frameId(), clientPos().x(), clientPos().y(), window());
         }
     } else if (app_noborder) {
         xcb_shape_mask(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING, frameId(), 0, 0, XCB_PIXMAP_NONE);
         detectNoBorder();
         app_noborder = noborder;
         noborder = rules()->checkNoBorder(noborder || m_motif.noBorder());
         updateDecoration(true);
     }
 
     // Decoration mask (i.e. 'else' here) setting is done in setMask()
     // when the decoration calls it or when the decoration is created/destroyed
     updateInputShape();
     if (compositing()) {
         addRepaintFull();
         addWorkspaceRepaint(visibleRect());   // In case shape change removes part of this window
     }
     emit geometryShapeChanged(this, frameGeometry());
 }
 
 static Xcb::Window shape_helper_window(XCB_WINDOW_NONE);
 
 void X11Client::cleanupX11()
 {
     shape_helper_window.reset();
 }
 
 void X11Client::updateInputShape()
 {
     if (hiddenPreview())   // Sets it to none, don't change
         return;
     if (Xcb::Extensions::self()->isShapeInputAvailable()) {
         // There appears to be no way to find out if a window has input
         // shape set or not, so always propagate the input shape
         // (it's the same like the bounding shape by default).
         // Also, build the shape using a helper window, not directly
         // in the frame window, because the sequence set-shape-to-frame,
         // remove-shape-of-client, add-input-shape-of-client has the problem
         // that after the second step there's a hole in the input shape
         // until the real shape of the client is added and that can make
         // the window lose focus (which is a problem with mouse focus policies)
         // TODO: It seems there is, after all - XShapeGetRectangles() - but maybe this is better
         if (!shape_helper_window.isValid())
             shape_helper_window.create(QRect(0, 0, 1, 1));
         shape_helper_window.resize(m_bufferGeometry.size());
         xcb_connection_t *c = connection();
         xcb_shape_combine(c, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_SHAPE_SK_BOUNDING,
                           shape_helper_window, 0, 0, frameId());
         xcb_shape_combine(c, XCB_SHAPE_SO_SUBTRACT, XCB_SHAPE_SK_INPUT, XCB_SHAPE_SK_BOUNDING,
                           shape_helper_window, clientPos().x(), clientPos().y(), window());
         xcb_shape_combine(c, XCB_SHAPE_SO_UNION, XCB_SHAPE_SK_INPUT, XCB_SHAPE_SK_INPUT,
                           shape_helper_window, clientPos().x(), clientPos().y(), window());
         xcb_shape_combine(c, XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT, XCB_SHAPE_SK_INPUT,
                           frameId(), 0, 0, shape_helper_window);
     }
 }
 
 void X11Client::hideClient(bool hide)
 {
     if (hidden == hide)
         return;
     hidden = hide;
     updateVisibility();
 }
 
 bool X11Client::setupCompositing()
 {
     if (!Toplevel::setupCompositing()){
         return false;
     }
     updateVisibility(); // for internalKeep()
     return true;
 }
 
 void X11Client::finishCompositing(ReleaseReason releaseReason)
 {
     Toplevel::finishCompositing(releaseReason);
     updateVisibility();
     // for safety in case KWin is just resizing the window
     resetHaveResizeEffect();
 }
 
 /**
  * Returns whether the window is minimizable or not
  */
 bool X11Client::isMinimizable() const
 {
     if (isSpecialWindow() && !isTransient())
         return false;
     if (!rules()->checkMinimize(true))
         return false;
 
     if (isTransient()) {
         // #66868 - Let other xmms windows be minimized when the mainwindow is minimized
         bool shown_mainwindow = false;
         auto mainclients = mainClients();
         for (auto it = mainclients.constBegin();
                 it != mainclients.constEnd();
                 ++it)
             if ((*it)->isShown(true))
                 shown_mainwindow = true;
         if (!shown_mainwindow)
             return true;
     }
 #if 0
     // This is here because kicker's taskbar doesn't provide separate entries
     // for windows with an explicitly given parent
     // TODO: perhaps this should be redone
     // Disabled for now, since at least modal dialogs should be minimizable
     // (resulting in the mainwindow being minimized too).
     if (transientFor() != NULL)
         return false;
 #endif
     if (!wantsTabFocus())   // SELI, TODO: - NET::Utility? why wantsTabFocus() - skiptaskbar? ?
         return false;
     return true;
 }
 
 void X11Client::doMinimize()
 {
     if (isShade()) {
         // NETWM restriction - KWindowInfo::isMinimized() == Hidden && !Shaded
         info->setState(isMinimized() ? NET::States() : NET::Shaded, NET::Shaded);
     }
     updateVisibility();
     updateAllowedActions();
     workspace()->updateMinimizedOfTransients(this);
 }
 
 QRect X11Client::iconGeometry() const
 {
     NETRect r = info->iconGeometry();
     QRect geom(r.pos.x, r.pos.y, r.size.width, r.size.height);
     if (geom.isValid())
         return geom;
     else {
         // Check all mainwindows of this window (recursively)
         foreach (AbstractClient * amainwin, mainClients()) {
             X11Client *mainwin = dynamic_cast<X11Client *>(amainwin);
             if (!mainwin) {
                 continue;
             }
             geom = mainwin->iconGeometry();
             if (geom.isValid())
                 return geom;
         }
         // No mainwindow (or their parents) with icon geometry was found
         return AbstractClient::iconGeometry();
     }
 }
 
 bool X11Client::isShadeable() const
 {
     return !isSpecialWindow() && !noBorder() && (rules()->checkShade(ShadeNormal) != rules()->checkShade(ShadeNone));
 }
 
-void X11Client::setShade(ShadeMode mode)
+void X11Client::doSetShade(ShadeMode previousShadeMode)
 {
-    if (mode == ShadeHover && isMove())
-        return; // causes geometry breaks and is probably nasty
-    if (isSpecialWindow() || noBorder())
-        mode = ShadeNone;
-    mode = rules()->checkShade(mode);
-    if (shade_mode == mode)
-        return;
-    bool was_shade = isShade();
-    ShadeMode was_shade_mode = shade_mode;
-    shade_mode = mode;
-
-    // Decorations may turn off some borders when shaded
-    // this has to happen _before_ the tab alignment since it will restrict the minimum geometry
-#if 0
-    if (decoration)
-        decoration->borders(border_left, border_right, border_top, border_bottom);
-#endif
-
-    if (was_shade == isShade()) {
-        // Decoration may want to update after e.g. hover-shade changes
-        emit shadeChanged();
-        return; // No real change in shaded state
-    }
-
-    Q_ASSERT(isDecorated());   // noborder windows can't be shaded
-    GeometryUpdatesBlocker blocker(this);
-
     // TODO: All this unmapping, resizing etc. feels too much duplicated from elsewhere
     if (isShade()) {
         // shade_mode == ShadeNormal
         addWorkspaceRepaint(visibleRect());
         // Shade
         shade_geometry_change = true;
         QSize s(adjustedSize());
         s.setHeight(borderTop() + borderBottom());
         m_wrapper.selectInput(ClientWinMask);   // Avoid getting UnmapNotify
         m_wrapper.unmap();
         m_client.unmap();
         m_wrapper.selectInput(ClientWinMask | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY);
         exportMappingState(XCB_ICCCM_WM_STATE_ICONIC);
         plainResize(s);
         shade_geometry_change = false;
-        if (was_shade_mode == ShadeHover) {
+        if (previousShadeMode == ShadeHover) {
             if (shade_below && workspace()->stackingOrder().indexOf(shade_below) > -1)
                     workspace()->restack(this, shade_below, true);
             if (isActive())
                 workspace()->activateNextClient(this);
         } else if (isActive()) {
             workspace()->focusToNull();
         }
     } else {
         shade_geometry_change = true;
         if (decoratedClient())
             decoratedClient()->signalShadeChange();
         QSize s(adjustedSize());
         shade_geometry_change = false;
         plainResize(s);
         setGeometryRestore(frameGeometry());
-        if ((shade_mode == ShadeHover || shade_mode == ShadeActivated) && rules()->checkAcceptFocus(info->input()))
+        if ((shadeMode() == ShadeHover || shadeMode() == ShadeActivated) && rules()->checkAcceptFocus(info->input()))
             setActive(true);
-        if (shade_mode == ShadeHover) {
+        if (shadeMode() == ShadeHover) {
             QList<Toplevel *> order = workspace()->stackingOrder();
             // invalidate, since "this" could be the topmost toplevel and shade_below dangeling
             shade_below = nullptr;
             // this is likely related to the index parameter?!
             for (int idx = order.indexOf(this) + 1; idx < order.count(); ++idx) {
                 shade_below = qobject_cast<X11Client *>(order.at(idx));
                 if (shade_below) {
                     break;
                 }
             }
             if (shade_below && shade_below->isNormalWindow())
                 workspace()->raiseClient(this);
             else
                 shade_below = nullptr;
         }
         m_wrapper.map();
         m_client.map();
         exportMappingState(XCB_ICCCM_WM_STATE_NORMAL);
         if (isActive())
             workspace()->requestFocus(this);
     }
     info->setState(isShade() ? NET::Shaded : NET::States(), NET::Shaded);
     info->setState(isShown(false) ? NET::States() : NET::Hidden, NET::Hidden);
-    discardWindowPixmap();
     updateVisibility();
     updateAllowedActions();
-    updateWindowRules(Rules::Shade);
-
-    emit shadeChanged();
-}
-
-void X11Client::shadeHover()
-{
-    setShade(ShadeHover);
-    cancelShadeHoverTimer();
-}
-
-void X11Client::shadeUnhover()
-{
-    setShade(ShadeNormal);
-    cancelShadeHoverTimer();
-}
-
-void X11Client::cancelShadeHoverTimer()
-{
-    delete shadeHoverTimer;
-    shadeHoverTimer = nullptr;
-}
-
-void X11Client::toggleShade()
-{
-    // If the mode is ShadeHover or ShadeActive, cancel shade too
-    setShade(shade_mode == ShadeNone ? ShadeNormal : ShadeNone);
 }
 
 void X11Client::updateVisibility()
 {
     if (deleting)
         return;
     if (hidden) {
         info->setState(NET::Hidden, NET::Hidden);
         setSkipTaskbar(true);   // Also hide from taskbar
         if (compositing() && options->hiddenPreviews() == HiddenPreviewsAlways)
             internalKeep();
         else
             internalHide();
         return;
     }
     setSkipTaskbar(originalSkipTaskbar());   // Reset from 'hidden'
     if (isMinimized()) {
         info->setState(NET::Hidden, NET::Hidden);
         if (compositing() && options->hiddenPreviews() == HiddenPreviewsAlways)
             internalKeep();
         else
             internalHide();
         return;
     }
     info->setState(NET::States(), NET::Hidden);
     if (!isOnCurrentDesktop()) {
         if (compositing() && options->hiddenPreviews() != HiddenPreviewsNever)
             internalKeep();
         else
             internalHide();
         return;
     }
     if (!isOnCurrentActivity()) {
         if (compositing() && options->hiddenPreviews() != HiddenPreviewsNever)
             internalKeep();
         else
             internalHide();
         return;
     }
     internalShow();
 }
 
 
 /**
  * Sets the client window's mapping state. Possible values are
  * WithdrawnState, IconicState, NormalState.
  */
 void X11Client::exportMappingState(int s)
 {
     Q_ASSERT(m_client != XCB_WINDOW_NONE);
     Q_ASSERT(!deleting || s == XCB_ICCCM_WM_STATE_WITHDRAWN);
     if (s == XCB_ICCCM_WM_STATE_WITHDRAWN) {
         m_client.deleteProperty(atoms->wm_state);
         return;
     }
     Q_ASSERT(s == XCB_ICCCM_WM_STATE_NORMAL || s == XCB_ICCCM_WM_STATE_ICONIC);
 
     int32_t data[2];
     data[0] = s;
     data[1] = XCB_NONE;
     m_client.changeProperty(atoms->wm_state, atoms->wm_state, 32, 2, data);
 }
 
 void X11Client::internalShow()
 {
     if (mapping_state == Mapped)
         return;
     MappingState old = mapping_state;
     mapping_state = Mapped;
     if (old == Unmapped || old == Withdrawn)
         map();
     if (old == Kept) {
         m_decoInputExtent.map();
         updateHiddenPreview();
     }
     emit windowShown(this);
 }
 
 void X11Client::internalHide()
 {
     if (mapping_state == Unmapped)
         return;
     MappingState old = mapping_state;
     mapping_state = Unmapped;
     if (old == Mapped || old == Kept)
         unmap();
     if (old == Kept)
         updateHiddenPreview();
     addWorkspaceRepaint(visibleRect());
     workspace()->clientHidden(this);
     emit windowHidden(this);
 }
 
 void X11Client::internalKeep()
 {
     Q_ASSERT(compositing());
     if (mapping_state == Kept)
         return;
     MappingState old = mapping_state;
     mapping_state = Kept;
     if (old == Unmapped || old == Withdrawn)
         map();
     m_decoInputExtent.unmap();
     if (isActive())
         workspace()->focusToNull(); // get rid of input focus, bug #317484
     updateHiddenPreview();
     addWorkspaceRepaint(visibleRect());
     workspace()->clientHidden(this);
 }
 
 /**
  * Maps (shows) the client. Note that it is mapping state of the frame,
  * not necessarily the client window itself (i.e. a shaded window is here
  * considered mapped, even though it is in IconicState).
  */
 void X11Client::map()
 {
     // XComposite invalidates backing pixmaps on unmap (minimize, different
     // virtual desktop, etc.).  We kept the last known good pixmap around
     // for use in effects, but now we want to have access to the new pixmap
     if (compositing())
         discardWindowPixmap();
     m_frame.map();
     if (!isShade()) {
         m_wrapper.map();
         m_client.map();
         m_decoInputExtent.map();
         exportMappingState(XCB_ICCCM_WM_STATE_NORMAL);
     } else
         exportMappingState(XCB_ICCCM_WM_STATE_ICONIC);
     addLayerRepaint(visibleRect());
 }
 
 /**
  * Unmaps the client. Again, this is about the frame.
  */
 void X11Client::unmap()
 {
     // Here it may look like a race condition, as some other client might try to unmap
     // the window between these two XSelectInput() calls. However, they're supposed to
     // use XWithdrawWindow(), which also sends a synthetic event to the root window,
     // which won't be missed, so this shouldn't be a problem. The chance the real UnmapNotify
     // will be missed is also very minimal, so I don't think it's needed to grab the server
     // here.
     m_wrapper.selectInput(ClientWinMask);   // Avoid getting UnmapNotify
     m_frame.unmap();
     m_wrapper.unmap();
     m_client.unmap();
     m_decoInputExtent.unmap();
     m_wrapper.selectInput(ClientWinMask | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY);
     exportMappingState(XCB_ICCCM_WM_STATE_ICONIC);
 }
 
 /**
  * XComposite doesn't keep window pixmaps of unmapped windows, which means
  * there wouldn't be any previews of windows that are minimized or on another
  * virtual desktop. Therefore rawHide() actually keeps such windows mapped.
  * However special care needs to be taken so that such windows don't interfere.
  * Therefore they're put very low in the stacking order and they have input shape
  * set to none, which hopefully is enough. If there's no input shape available,
  * then it's hoped that there will be some other desktop above it *shrug*.
  * Using normal shape would be better, but that'd affect other things, e.g. painting
  * of the actual preview.
  */
 void X11Client::updateHiddenPreview()
 {
     if (hiddenPreview()) {
         workspace()->forceRestacking();
         if (Xcb::Extensions::self()->isShapeInputAvailable()) {
             xcb_shape_rectangles(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_INPUT,
                                  XCB_CLIP_ORDERING_UNSORTED, frameId(), 0, 0, 0, nullptr);
         }
     } else {
         workspace()->forceRestacking();
         updateInputShape();
     }
 }
 
 void X11Client::sendClientMessage(xcb_window_t w, xcb_atom_t a, xcb_atom_t protocol, uint32_t data1, uint32_t data2, uint32_t data3, xcb_timestamp_t timestamp)
 {
     xcb_client_message_event_t ev;
     memset(&ev, 0, sizeof(ev));
     ev.response_type = XCB_CLIENT_MESSAGE;
     ev.window = w;
     ev.type = a;
     ev.format = 32;
     ev.data.data32[0] = protocol;
     ev.data.data32[1] = timestamp;
     ev.data.data32[2] = data1;
     ev.data.data32[3] = data2;
     ev.data.data32[4] = data3;
     uint32_t eventMask = 0;
     if (w == rootWindow()) {
         eventMask = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT; // Magic!
     }
     xcb_send_event(connection(), false, w, eventMask, reinterpret_cast<const char*>(&ev));
     xcb_flush(connection());
 }
 
 /**
  * Returns whether the window may be closed (have a close button)
  */
 bool X11Client::isCloseable() const
 {
     return rules()->checkCloseable(m_motif.close() && !isSpecialWindow());
 }
 
 /**
  * Closes the window by either sending a delete_window message or using XKill.
  */
 void X11Client::closeWindow()
 {
     if (!isCloseable())
         return;
 
     // Update user time, because the window may create a confirming dialog.
     updateUserTime();
 
     if (info->supportsProtocol(NET::DeleteWindowProtocol)) {
         sendClientMessage(window(), atoms->wm_protocols, atoms->wm_delete_window);
         pingWindow();
     } else // Client will not react on wm_delete_window. We have not choice
         // but destroy his connection to the XServer.
         killWindow();
 }
 
 
 /**
  * Kills the window via XKill
  */
 void X11Client::killWindow()
 {
     qCDebug(KWIN_CORE) << "X11Client::killWindow():" << caption();
     killProcess(false);
     m_client.kill();  // Always kill this client at the server
     destroyClient();
 }
 
 /**
  * Send a ping to the window using _NET_WM_PING if possible if it
  * doesn't respond within a reasonable time, it will be killed.
  */
 void X11Client::pingWindow()
 {
     if (!info->supportsProtocol(NET::PingProtocol))
         return; // Can't ping :(
     if (options->killPingTimeout() == 0)
         return; // Turned off
     if (ping_timer != nullptr)
         return; // Pinging already
     ping_timer = new QTimer(this);
     connect(ping_timer, &QTimer::timeout, this,
         [this]() {
             if (unresponsive()) {
                 qCDebug(KWIN_CORE) << "Final ping timeout, asking to kill:" << caption();
                 ping_timer->deleteLater();
                 ping_timer = nullptr;
                 killProcess(true, m_pingTimestamp);
                 return;
             }
 
             qCDebug(KWIN_CORE) << "First ping timeout:" << caption();
 
             setUnresponsive(true);
             ping_timer->start();
         }
     );
     ping_timer->setSingleShot(true);
     // we'll run the timer twice, at first we'll desaturate the window
     // and the second time we'll show the "do you want to kill" prompt
     ping_timer->start(options->killPingTimeout() / 2);
     m_pingTimestamp = xTime();
     rootInfo()->sendPing(window(), m_pingTimestamp);
 }
 
 void X11Client::gotPing(xcb_timestamp_t timestamp)
 {
     // Just plain compare is not good enough because of 64bit and truncating and whatnot
     if (NET::timestampCompare(timestamp, m_pingTimestamp) != 0)
         return;
     delete ping_timer;
     ping_timer = nullptr;
 
     setUnresponsive(false);
 
     if (m_killHelperPID && !::kill(m_killHelperPID, 0)) { // means the process is alive
         ::kill(m_killHelperPID, SIGTERM);
         m_killHelperPID = 0;
     }
 }
 
 void X11Client::killProcess(bool ask, xcb_timestamp_t timestamp)
 {
     if (m_killHelperPID && !::kill(m_killHelperPID, 0)) // means the process is alive
         return;
     Q_ASSERT(!ask || timestamp != XCB_TIME_CURRENT_TIME);
     pid_t pid = info->pid();
     if (pid <= 0 || clientMachine()->hostName().isEmpty())  // Needed properties missing
         return;
     qCDebug(KWIN_CORE) << "Kill process:" << pid << "(" << clientMachine()->hostName() << ")";
     if (!ask) {
         if (!clientMachine()->isLocal()) {
             QStringList lst;
             lst << QString::fromUtf8(clientMachine()->hostName()) << QStringLiteral("kill") << QString::number(pid);
             QProcess::startDetached(QStringLiteral("xon"), lst);
         } else
             ::kill(pid, SIGTERM);
     } else {
         QString hostname = clientMachine()->isLocal() ? QStringLiteral("localhost") : QString::fromUtf8(clientMachine()->hostName());
         // execute helper from build dir or the system installed one
         const QFileInfo buildDirBinary{QDir{QCoreApplication::applicationDirPath()}, QStringLiteral("kwin_killer_helper")};
         QProcess::startDetached(buildDirBinary.exists() ? buildDirBinary.absoluteFilePath() : QStringLiteral(KWIN_KILLER_BIN),
                                 QStringList() << QStringLiteral("--pid") << QString::number(unsigned(pid)) << QStringLiteral("--hostname") << hostname
                                 << QStringLiteral("--windowname") << captionNormal()
                                 << QStringLiteral("--applicationname") << QString::fromUtf8(resourceClass())
                                 << QStringLiteral("--wid") << QString::number(window())
                                 << QStringLiteral("--timestamp") << QString::number(timestamp),
                                 QString(), &m_killHelperPID);
     }
 }
 
 void X11Client::doSetKeepAbove()
 {
     info->setState(keepAbove() ? NET::KeepAbove : NET::States(), NET::KeepAbove);
 }
 
 void X11Client::doSetKeepBelow()
 {
     info->setState(keepBelow() ? NET::KeepBelow : NET::States(), NET::KeepBelow);
 }
 
 void X11Client::doSetSkipTaskbar()
 {
     info->setState(skipTaskbar() ? NET::SkipTaskbar : NET::States(), NET::SkipTaskbar);
 }
 
 void X11Client::doSetSkipPager()
 {
     info->setState(skipPager() ? NET::SkipPager : NET::States(), NET::SkipPager);
 }
 
 void X11Client::doSetSkipSwitcher()
 {
     info->setState(skipSwitcher() ? NET::SkipSwitcher : NET::States(), NET::SkipSwitcher);
 }
 
 void X11Client::doSetDesktop()
 {
     updateVisibility();
 }
 
 void X11Client::doSetDemandsAttention()
 {
     info->setState(isDemandingAttention() ? NET::DemandsAttention : NET::States(), NET::DemandsAttention);
 }
 
 /**
  * Sets whether the client is on @p activity.
  * If you remove it from its last activity, then it's on all activities.
  *
  * Note: If it was on all activities and you try to remove it from one, nothing will happen;
  * I don't think that's an important enough use case to handle here.
  */
 void X11Client::setOnActivity(const QString &activity, bool enable)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (! Activities::self()) {
         return;
     }
     QStringList newActivitiesList = activities();
     if (newActivitiesList.contains(activity) == enable)   //nothing to do
         return;
     if (enable) {
         QStringList allActivities = Activities::self()->all();
         if (!allActivities.contains(activity))   //bogus ID
             return;
         newActivitiesList.append(activity);
     } else
         newActivitiesList.removeOne(activity);
     setOnActivities(newActivitiesList);
 #else
     Q_UNUSED(activity)
     Q_UNUSED(enable)
 #endif
 }
 
 /**
  * set exactly which activities this client is on
  */
 void X11Client::setOnActivities(QStringList newActivitiesList)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     QString joinedActivitiesList = newActivitiesList.join(QStringLiteral(","));
     joinedActivitiesList = rules()->checkActivity(joinedActivitiesList, false);
     newActivitiesList = joinedActivitiesList.split(u',', QString::SkipEmptyParts);
 
     QStringList allActivities = Activities::self()->all();
 
     auto it = newActivitiesList.begin();
     while (it != newActivitiesList.end()) {
         if (! allActivities.contains(*it)) {
             it = newActivitiesList.erase(it);
         } else {
             it++;
         }
     }
 
     if (// If we got the request to be on all activities explicitly
         newActivitiesList.isEmpty() || joinedActivitiesList == Activities::nullUuid() ||
         // If we got a list of activities that covers all activities
         (newActivitiesList.count() > 1 && newActivitiesList.count() == allActivities.count())) {
 
         activityList.clear();
         const QByteArray nullUuid = Activities::nullUuid().toUtf8();
         m_client.changeProperty(atoms->activities, XCB_ATOM_STRING, 8, nullUuid.length(), nullUuid.constData());
 
     } else {
         QByteArray joined = joinedActivitiesList.toLatin1();
         activityList = newActivitiesList;
         m_client.changeProperty(atoms->activities, XCB_ATOM_STRING, 8, joined.length(), joined.constData());
     }
 
     updateActivities(false);
 #else
     Q_UNUSED(newActivitiesList)
 #endif
 }
 
 void X11Client::blockActivityUpdates(bool b)
 {
     if (b) {
         ++m_activityUpdatesBlocked;
     } else {
         Q_ASSERT(m_activityUpdatesBlocked);
         --m_activityUpdatesBlocked;
         if (!m_activityUpdatesBlocked)
             updateActivities(m_blockedActivityUpdatesRequireTransients);
     }
 }
 
 /**
  * update after activities changed
  */
 void X11Client::updateActivities(bool includeTransients)
 {
     if (m_activityUpdatesBlocked) {
         m_blockedActivityUpdatesRequireTransients |= includeTransients;
         return;
     }
     emit activitiesChanged(this);
     m_blockedActivityUpdatesRequireTransients = false; // reset
     FocusChain::self()->update(this, FocusChain::MakeFirst);
     updateVisibility();
     updateWindowRules(Rules::Activity);
 }
 
 /**
  * Returns the list of activities the client window is on.
  * if it's on all activities, the list will be empty.
  * Don't use this, use isOnActivity() and friends (from class Toplevel)
  */
 QStringList X11Client::activities() const
 {
     if (sessionActivityOverride) {
         return QStringList();
     }
     return activityList;
 }
 
 /**
  * if @p on is true, sets on all activities.
  * if it's false, sets it to only be on the current activity
  */
 void X11Client::setOnAllActivities(bool on)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (on == isOnAllActivities())
         return;
     if (on) {
         setOnActivities(QStringList());
 
     } else {
         setOnActivity(Activities::self()->current(), true);
     }
 #else
     Q_UNUSED(on)
 #endif
 }
 
 /**
  * Performs the actual focusing of the window using XSetInputFocus and WM_TAKE_FOCUS
  */
 void X11Client::takeFocus()
 {
     if (rules()->checkAcceptFocus(info->input()))
         m_client.focus();
     else
         demandAttention(false); // window cannot take input, at least withdraw urgency
     if (info->supportsProtocol(NET::TakeFocusProtocol)) {
         sendClientMessage(window(), atoms->wm_protocols, atoms->wm_take_focus, 0, 0, 0, XCB_CURRENT_TIME);
     }
     workspace()->setShouldGetFocus(this);
 
     bool breakShowingDesktop = !keepAbove();
     if (breakShowingDesktop) {
         foreach (const X11Client *c, group()->members()) {
             if (c->isDesktop()) {
                 breakShowingDesktop = false;
                 break;
             }
         }
     }
     if (breakShowingDesktop)
         workspace()->setShowingDesktop(false);
 }
 
 /**
  * Returns whether the window provides context help or not. If it does,
  * you should show a help menu item or a help button like '?' and call
  * contextHelp() if this is invoked.
  *
  * \sa contextHelp()
  */
 bool X11Client::providesContextHelp() const
 {
     return info->supportsProtocol(NET::ContextHelpProtocol);
 }
 
 /**
  * Invokes context help on the window. Only works if the window
  * actually provides context help.
  *
  * \sa providesContextHelp()
  */
 void X11Client::showContextHelp()
 {
     if (info->supportsProtocol(NET::ContextHelpProtocol)) {
         sendClientMessage(window(), atoms->wm_protocols, atoms->net_wm_context_help);
     }
 }
 
 /**
  * Fetches the window's caption (WM_NAME property). It will be
  * stored in the client's caption().
  */
 void X11Client::fetchName()
 {
     setCaption(readName());
 }
 
 static inline QString readNameProperty(xcb_window_t w, xcb_atom_t atom)
 {
     const auto cookie = xcb_icccm_get_text_property_unchecked(connection(), w, atom);
     xcb_icccm_get_text_property_reply_t reply;
     if (xcb_icccm_get_wm_name_reply(connection(), cookie, &reply, nullptr)) {
         QString retVal;
         if (reply.encoding == atoms->utf8_string) {
             retVal = QString::fromUtf8(QByteArray(reply.name, reply.name_len));
         } else if (reply.encoding == XCB_ATOM_STRING) {
             retVal = QString::fromLocal8Bit(QByteArray(reply.name, reply.name_len));
         }
         xcb_icccm_get_text_property_reply_wipe(&reply);
         return retVal.simplified();
     }
     return QString();
 }
 
 QString X11Client::readName() const
 {
     if (info->name() && info->name()[0] != '\0')
         return QString::fromUtf8(info->name()).simplified();
     else {
         return readNameProperty(window(), XCB_ATOM_WM_NAME);
     }
 }
 
 // The list is taken from https://www.unicode.org/reports/tr9/ (#154840)
 static const QChar LRM(0x200E);
 
 void X11Client::setCaption(const QString& _s, bool force)
 {
     QString s(_s);
     for (int i = 0; i < s.length(); ) {
         if (!s[i].isPrint()) {
             if (QChar(s[i]).isHighSurrogate() && i + 1 < s.length() && QChar(s[i + 1]).isLowSurrogate()) {
                 const uint uc = QChar::surrogateToUcs4(s[i], s[i + 1]);
                 if (!QChar::isPrint(uc)) {
                     s.remove(i, 2);
                 } else {
                     i += 2;
                 }
                 continue;
             }
             s.remove(i, 1);
             continue;
         }
         ++i;
     }
     const bool changed = (s != cap_normal);
     if (!force && !changed) {
         return;
     }
     cap_normal = s;
     if (!force && !changed) {
         emit captionChanged();
         return;
     }
 
     bool reset_name = force;
     bool was_suffix = (!cap_suffix.isEmpty());
     cap_suffix.clear();
     QString machine_suffix;
     if (!options->condensedTitle()) { // machine doesn't qualify for "clean"
         if (clientMachine()->hostName() != ClientMachine::localhost() && !clientMachine()->isLocal())
             machine_suffix = QLatin1String(" <@") + QString::fromUtf8(clientMachine()->hostName()) + QLatin1Char('>') + LRM;
     }
     QString shortcut_suffix = shortcutCaptionSuffix();
     cap_suffix = machine_suffix + shortcut_suffix;
     if ((!isSpecialWindow() || isToolbar()) && findClientWithSameCaption()) {
         int i = 2;
         do {
             cap_suffix = machine_suffix + QLatin1String(" <") + QString::number(i) + QLatin1Char('>') + LRM;
             i++;
         } while (findClientWithSameCaption());
         info->setVisibleName(caption().toUtf8().constData());
         reset_name = false;
     }
     if ((was_suffix && cap_suffix.isEmpty()) || reset_name) {
         // If it was new window, it may have old value still set, if the window is reused
         info->setVisibleName("");
         info->setVisibleIconName("");
     } else if (!cap_suffix.isEmpty() && !cap_iconic.isEmpty())
         // Keep the same suffix in iconic name if it's set
         info->setVisibleIconName(QString(cap_iconic + cap_suffix).toUtf8().constData());
 
     emit captionChanged();
 }
 
 void X11Client::updateCaption()
 {
     setCaption(cap_normal, true);
 }
 
 void X11Client::fetchIconicName()
 {
     QString s;
     if (info->iconName() && info->iconName()[0] != '\0')
         s = QString::fromUtf8(info->iconName());
     else
         s = readNameProperty(window(), XCB_ATOM_WM_ICON_NAME);
     if (s != cap_iconic) {
         bool was_set = !cap_iconic.isEmpty();
         cap_iconic = s;
         if (!cap_suffix.isEmpty()) {
             if (!cap_iconic.isEmpty())  // Keep the same suffix in iconic name if it's set
                 info->setVisibleIconName(QString(s + cap_suffix).toUtf8().constData());
             else if (was_set)
                 info->setVisibleIconName("");
         }
     }
 }
 
 void X11Client::setClientShown(bool shown)
 {
     if (deleting)
         return; // Don't change shown status if this client is being deleted
     if (shown != hidden)
         return; // nothing to change
     hidden = !shown;
     if (shown) {
         map();
         takeFocus();
         autoRaise();
         FocusChain::self()->update(this, FocusChain::MakeFirst);
     } else {
         unmap();
         // Don't move tabs to the end of the list when another tab get's activated
         FocusChain::self()->update(this, FocusChain::MakeLast);
         addWorkspaceRepaint(visibleRect());
     }
 }
 
 void X11Client::getMotifHints()
 {
     const bool wasClosable = m_motif.close();
     const bool wasNoBorder = m_motif.noBorder();
     if (m_managed) // only on property change, initial read is prefetched
         m_motif.fetch();
     m_motif.read();
     if (m_motif.hasDecoration() && m_motif.noBorder() != wasNoBorder) {
         // If we just got a hint telling us to hide decorations, we do so.
         if (m_motif.noBorder())
             noborder = rules()->checkNoBorder(true);
         // If the Motif hint is now telling us to show decorations, we only do so if the app didn't
         // instruct us to hide decorations in some other way, though.
         else if (!app_noborder)
             noborder = rules()->checkNoBorder(false);
     }
 
     // mminimize; - Ignore, bogus - E.g. shading or sending to another desktop is "minimizing" too
     // mmaximize; - Ignore, bogus - Maximizing is basically just resizing
     const bool closabilityChanged = wasClosable != m_motif.close();
     if (isManaged())
         updateDecoration(true);   // Check if noborder state has changed
     if (closabilityChanged) {
         emit closeableChanged(isCloseable());
     }
 }
 
 void X11Client::getIcons()
 {
     // First read icons from the window itself
     const QString themedIconName = iconFromDesktopFile();
     if (!themedIconName.isEmpty()) {
         setIcon(QIcon::fromTheme(themedIconName));
         return;
     }
     QIcon icon;
     auto readIcon = [this, &icon](int size, bool scale = true) {
         const QPixmap pix = KWindowSystem::icon(window(), size, size, scale, KWindowSystem::NETWM | KWindowSystem::WMHints, info);
         if (!pix.isNull()) {
             icon.addPixmap(pix);
         }
     };
     readIcon(16);
     readIcon(32);
     readIcon(48, false);
     readIcon(64, false);
     readIcon(128, false);
     if (icon.isNull()) {
         // Then try window group
         icon = group()->icon();
     }
     if (icon.isNull() && isTransient()) {
         // Then mainclients
         auto mainclients = mainClients();
         for (auto it = mainclients.constBegin();
                 it != mainclients.constEnd() && icon.isNull();
                 ++it) {
             if (!(*it)->icon().isNull()) {
                 icon = (*it)->icon();
                 break;
             }
         }
     }
     if (icon.isNull()) {
         // And if nothing else, load icon from classhint or xapp icon
         icon.addPixmap(KWindowSystem::icon(window(),  32,  32,  true, KWindowSystem::ClassHint | KWindowSystem::XApp, info));
         icon.addPixmap(KWindowSystem::icon(window(),  16,  16,  true, KWindowSystem::ClassHint | KWindowSystem::XApp, info));
         icon.addPixmap(KWindowSystem::icon(window(),  64,  64, false, KWindowSystem::ClassHint | KWindowSystem::XApp, info));
         icon.addPixmap(KWindowSystem::icon(window(), 128, 128, false, KWindowSystem::ClassHint | KWindowSystem::XApp, info));
     }
     setIcon(icon);
 }
 
 /**
  * Returns \c true if X11Client wants to throttle resizes; otherwise returns \c false.
  */
 bool X11Client::wantsSyncCounter() const
 {
     return true;
 }
 
 void X11Client::getSyncCounter()
 {
     if (!Xcb::Extensions::self()->isSyncAvailable())
         return;
     if (!wantsSyncCounter())
         return;
 
     Xcb::Property syncProp(false, window(), atoms->net_wm_sync_request_counter, XCB_ATOM_CARDINAL, 0, 1);
     const xcb_sync_counter_t counter = syncProp.value<xcb_sync_counter_t>(XCB_NONE);
     if (counter != XCB_NONE) {
         m_syncRequest.counter = counter;
         m_syncRequest.value.hi = 0;
         m_syncRequest.value.lo = 0;
         auto *c = connection();
         xcb_sync_set_counter(c, m_syncRequest.counter, m_syncRequest.value);
         if (m_syncRequest.alarm == XCB_NONE) {
             const uint32_t mask = XCB_SYNC_CA_COUNTER | XCB_SYNC_CA_VALUE_TYPE | XCB_SYNC_CA_TEST_TYPE | XCB_SYNC_CA_EVENTS;
             const uint32_t values[] = {
                 m_syncRequest.counter,
                 XCB_SYNC_VALUETYPE_RELATIVE,
                 XCB_SYNC_TESTTYPE_POSITIVE_TRANSITION,
                 1
             };
             m_syncRequest.alarm = xcb_generate_id(c);
             auto cookie = xcb_sync_create_alarm_checked(c, m_syncRequest.alarm, mask, values);
             ScopedCPointer<xcb_generic_error_t> error(xcb_request_check(c, cookie));
             if (!error.isNull()) {
                 m_syncRequest.alarm = XCB_NONE;
             } else {
                 xcb_sync_change_alarm_value_list_t value;
                 memset(&value, 0, sizeof(value));
                 value.value.hi = 0;
                 value.value.lo = 1;
                 value.delta.hi = 0;
                 value.delta.lo = 1;
                 xcb_sync_change_alarm_aux(c, m_syncRequest.alarm, XCB_SYNC_CA_DELTA | XCB_SYNC_CA_VALUE, &value);
             }
         }
     }
 }
 
 /**
  * Send the client a _NET_SYNC_REQUEST
  */
 void X11Client::sendSyncRequest()
 {
     if (m_syncRequest.counter == XCB_NONE || m_syncRequest.isPending) {
         return; // do NOT, NEVER send a sync request when there's one on the stack. the clients will just stop respoding. FOREVER! ...
     }
 
     if (!m_syncRequest.failsafeTimeout) {
         m_syncRequest.failsafeTimeout = new QTimer(this);
         connect(m_syncRequest.failsafeTimeout, &QTimer::timeout, this,
             [this]() {
                 // client does not respond to XSYNC requests in reasonable time, remove support
                 if (!ready_for_painting) {
                     // failed on initial pre-show request
                     setReadyForPainting();
                     setupWindowManagementInterface();
                     return;
                 }
                 // failed during resize
                 m_syncRequest.isPending = false;
                 m_syncRequest.counter = XCB_NONE;
                 m_syncRequest.alarm = XCB_NONE;
                 delete m_syncRequest.timeout;
                 delete m_syncRequest.failsafeTimeout;
                 m_syncRequest.timeout = nullptr;
                 m_syncRequest.failsafeTimeout = nullptr;
                 m_syncRequest.lastTimestamp = XCB_CURRENT_TIME;
             }
         );
         m_syncRequest.failsafeTimeout->setSingleShot(true);
     }
     // if there's no response within 10 seconds, sth. went wrong and we remove XSYNC support from this client.
     // see events.cpp X11Client::syncEvent()
     m_syncRequest.failsafeTimeout->start(ready_for_painting ? 10000 : 1000);
 
     // We increment before the notify so that after the notify
     // syncCounterSerial will equal the value we are expecting
     // in the acknowledgement
     const uint32_t oldLo = m_syncRequest.value.lo;
     m_syncRequest.value.lo++;
     if (oldLo > m_syncRequest.value.lo) {
         m_syncRequest.value.hi++;
     }
     if (m_syncRequest.lastTimestamp >= xTime()) {
         updateXTime();
     }
 
     // Send the message to client
     sendClientMessage(window(), atoms->wm_protocols, atoms->net_wm_sync_request,
                       m_syncRequest.value.lo, m_syncRequest.value.hi);
     m_syncRequest.isPending = true;
     m_syncRequest.lastTimestamp = xTime();
 }
 
 bool X11Client::wantsInput() const
 {
     return rules()->checkAcceptFocus(acceptsFocus() || info->supportsProtocol(NET::TakeFocusProtocol));
 }
 
 bool X11Client::acceptsFocus() const
 {
     return info->input();
 }
 
 void X11Client::setBlockingCompositing(bool block)
 {
     const bool usedToBlock = blocks_compositing;
     blocks_compositing = rules()->checkBlockCompositing(block && options->windowsBlockCompositing());
     if (usedToBlock != blocks_compositing) {
         emit blockingCompositingChanged(blocks_compositing ? this : nullptr);
     }
 }
 
 void X11Client::updateAllowedActions(bool force)
 {
     if (!isManaged() && !force)
         return;
     NET::Actions old_allowed_actions = NET::Actions(allowed_actions);
     allowed_actions = NET::Actions();
     if (isMovable())
         allowed_actions |= NET::ActionMove;
     if (isResizable())
         allowed_actions |= NET::ActionResize;
     if (isMinimizable())
         allowed_actions |= NET::ActionMinimize;
     if (isShadeable())
         allowed_actions |= NET::ActionShade;
     // Sticky state not supported
     if (isMaximizable())
         allowed_actions |= NET::ActionMax;
     if (userCanSetFullScreen())
         allowed_actions |= NET::ActionFullScreen;
     allowed_actions |= NET::ActionChangeDesktop; // Always (Pagers shouldn't show Docks etc.)
     if (isCloseable())
         allowed_actions |= NET::ActionClose;
     if (old_allowed_actions == allowed_actions)
         return;
     // TODO: This could be delayed and compressed - It's only for pagers etc. anyway
     info->setAllowedActions(allowed_actions);
 
     // ONLY if relevant features have changed (and the window didn't just get/loose moveresize for maximization state changes)
     const NET::Actions relevant = ~(NET::ActionMove|NET::ActionResize);
     if ((allowed_actions & relevant) != (old_allowed_actions & relevant)) {
         if ((allowed_actions & NET::ActionMinimize) != (old_allowed_actions & NET::ActionMinimize)) {
             emit minimizeableChanged(allowed_actions & NET::ActionMinimize);
         }
         if ((allowed_actions & NET::ActionShade) != (old_allowed_actions & NET::ActionShade)) {
             emit shadeableChanged(allowed_actions & NET::ActionShade);
         }
         if ((allowed_actions & NET::ActionMax) != (old_allowed_actions & NET::ActionMax)) {
             emit maximizeableChanged(allowed_actions & NET::ActionMax);
         }
     }
 }
 
 void X11Client::debug(QDebug& stream) const
 {
     stream.nospace();
     print<QDebug>(stream);
 }
 
 Xcb::StringProperty X11Client::fetchActivities() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     return Xcb::StringProperty(window(), atoms->activities);
 #else
     return Xcb::StringProperty();
 #endif
 }
 
 void X11Client::readActivities(Xcb::StringProperty &property)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     QStringList newActivitiesList;
     QString prop = QString::fromUtf8(property);
     activitiesDefined = !prop.isEmpty();
 
     if (prop == Activities::nullUuid()) {
         //copied from setOnAllActivities to avoid a redundant XChangeProperty.
         if (!activityList.isEmpty()) {
             activityList.clear();
             updateActivities(true);
         }
         return;
     }
     if (prop.isEmpty()) {
         //note: this makes it *act* like it's on all activities but doesn't set the property to 'ALL'
         if (!activityList.isEmpty()) {
             activityList.clear();
             updateActivities(true);
         }
         return;
     }
 
     newActivitiesList = prop.split(u',');
 
     if (newActivitiesList == activityList)
         return; //expected change, it's ok.
 
     //otherwise, somebody else changed it. we need to validate before reacting.
     //if the activities are not synced, and there are existing clients with
     //activities specified, somebody has restarted kwin. we can not validate
     //activities in this case. we need to trust the old values.
     if (Activities::self() && Activities::self()->serviceStatus() != KActivities::Consumer::Unknown) {
         QStringList allActivities = Activities::self()->all();
         if (allActivities.isEmpty()) {
             qCDebug(KWIN_CORE) << "no activities!?!?";
             //don't touch anything, there's probably something bad going on and we don't wanna make it worse
             return;
         }
 
 
         for (int i = 0; i < newActivitiesList.size(); ++i) {
             if (! allActivities.contains(newActivitiesList.at(i))) {
                 qCDebug(KWIN_CORE) << "invalid:" << newActivitiesList.at(i);
                 newActivitiesList.removeAt(i--);
             }
         }
     }
     setOnActivities(newActivitiesList);
 #else
     Q_UNUSED(property)
 #endif
 }
 
 void X11Client::checkActivities()
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     Xcb::StringProperty property = fetchActivities();
     readActivities(property);
 #endif
 }
 
 void X11Client::setSessionActivityOverride(bool needed)
 {
     sessionActivityOverride = needed;
     updateActivities(false);
 }
 
 Xcb::Property X11Client::fetchFirstInTabBox() const
 {
     return Xcb::Property(false, m_client, atoms->kde_first_in_window_list,
                          atoms->kde_first_in_window_list, 0, 1);
 }
 
 void X11Client::readFirstInTabBox(Xcb::Property &property)
 {
     setFirstInTabBox(property.toBool(32, atoms->kde_first_in_window_list));
 }
 
 void X11Client::updateFirstInTabBox()
 {
     // TODO: move into KWindowInfo
     Xcb::Property property = fetchFirstInTabBox();
     readFirstInTabBox(property);
 }
 
 Xcb::StringProperty X11Client::fetchColorScheme() const
 {
     return Xcb::StringProperty(m_client, atoms->kde_color_sheme);
 }
 
 void X11Client::readColorScheme(Xcb::StringProperty &property)
 {
     AbstractClient::updateColorScheme(rules()->checkDecoColor(QString::fromUtf8(property)));
 }
 
 void X11Client::updateColorScheme()
 {
     Xcb::StringProperty property = fetchColorScheme();
     readColorScheme(property);
 }
 
 bool X11Client::isClient() const
 {
     return true;
 }
 
 NET::WindowType X11Client::windowType(bool direct, int supportedTypes) const
 {
     // TODO: does it make sense to cache the returned window type for SUPPORTED_MANAGED_WINDOW_TYPES_MASK?
     if (supportedTypes == 0) {
         supportedTypes = SUPPORTED_MANAGED_WINDOW_TYPES_MASK;
     }
     NET::WindowType wt = info->windowType(NET::WindowTypes(supportedTypes));
     if (direct) {
         return wt;
     }
     NET::WindowType wt2 = rules()->checkType(wt);
     if (wt != wt2) {
         wt = wt2;
         info->setWindowType(wt);   // force hint change
     }
     // hacks here
     if (wt == NET::Unknown)   // this is more or less suggested in NETWM spec
         wt = isTransient() ? NET::Dialog : NET::Normal;
     return wt;
 }
 
 void X11Client::cancelFocusOutTimer()
 {
     if (m_focusOutTimer) {
         m_focusOutTimer->stop();
     }
 }
 
 xcb_window_t X11Client::frameId() const
 {
     return m_frame;
 }
 
 QRect X11Client::inputGeometry() const
 {
     // Notice that the buffer geometry corresponds to the geometry of the frame window.
     if (isDecorated()) {
         return m_bufferGeometry + decoration()->resizeOnlyBorders();
     }
     return m_bufferGeometry;
 }
 
 QRect X11Client::bufferGeometry() const
 {
     return m_bufferGeometry;
 }
 
 QMargins X11Client::bufferMargins() const
 {
     return QMargins(borderLeft(), borderTop(), borderRight(), borderBottom());
 }
 
 QPoint X11Client::framePosToClientPos(const QPoint &point) const
 {
     int x = point.x();
     int y = point.y();
 
     if (isDecorated()) {
         x += borderLeft();
         y += borderTop();
     } else {
         x -= m_clientFrameExtents.left();
         y -= m_clientFrameExtents.top();
     }
 
     return QPoint(x, y);
 }
 
 QPoint X11Client::clientPosToFramePos(const QPoint &point) const
 {
     int x = point.x();
     int y = point.y();
 
     if (isDecorated()) {
         x -= borderLeft();
         y -= borderTop();
     } else {
         x += m_clientFrameExtents.left();
         y += m_clientFrameExtents.top();
     }
 
     return QPoint(x, y);
 }
 
 QSize X11Client::frameSizeToClientSize(const QSize &size) const
 {
     int width = size.width();
     int height = size.height();
 
     if (isDecorated()) {
         width -= borderLeft() + borderRight();
         height -= borderTop() + borderBottom();
     } else {
         width += m_clientFrameExtents.left() + m_clientFrameExtents.right();
         height += m_clientFrameExtents.top() + m_clientFrameExtents.bottom();
     }
 
     return QSize(width, height);
 }
 
 QSize X11Client::clientSizeToFrameSize(const QSize &size) const
 {
     int width = size.width();
     int height = size.height();
 
     if (isDecorated()) {
         width += borderLeft() + borderRight();
         height += borderTop() + borderBottom();
     } else {
         width -= m_clientFrameExtents.left() + m_clientFrameExtents.right();
         height -= m_clientFrameExtents.top() + m_clientFrameExtents.bottom();
     }
 
     return QSize(width, height);
 }
 
 QRect X11Client::frameRectToBufferRect(const QRect &rect) const
 {
     if (isDecorated()) {
         return rect;
     }
     return frameRectToClientRect(rect);
 }
 
 QMatrix4x4 X11Client::inputTransformation() const
 {
     QMatrix4x4 matrix;
     matrix.translate(-m_bufferGeometry.x(), -m_bufferGeometry.y());
     return matrix;
 }
 
 Xcb::Property X11Client::fetchShowOnScreenEdge() const
 {
     return Xcb::Property(false, window(), atoms->kde_screen_edge_show, XCB_ATOM_CARDINAL, 0, 1);
 }
 
 void X11Client::readShowOnScreenEdge(Xcb::Property &property)
 {
     //value comes in two parts, edge in the lower byte
     //then the type in the upper byte
     // 0 = autohide
     // 1 = raise in front on activate
 
     const uint32_t value = property.value<uint32_t>(ElectricNone);
     ElectricBorder border = ElectricNone;
     switch (value & 0xFF) {
     case 0:
         border = ElectricTop;
         break;
     case 1:
         border = ElectricRight;
         break;
     case 2:
         border = ElectricBottom;
         break;
     case 3:
         border = ElectricLeft;
         break;
     }
     if (border != ElectricNone) {
         disconnect(m_edgeRemoveConnection);
         disconnect(m_edgeGeometryTrackingConnection);
         bool successfullyHidden = false;
 
         if (((value >> 8) & 0xFF) == 1) {
             setKeepBelow(true);
             successfullyHidden = keepBelow(); //request could have failed due to user kwin rules
 
             m_edgeRemoveConnection = connect(this, &AbstractClient::keepBelowChanged, this, [this](){
                 if (!keepBelow()) {
                     ScreenEdges::self()->reserve(this, ElectricNone);
                 }
             });
         } else {
             hideClient(true);
             successfullyHidden = isHiddenInternal();
 
             m_edgeGeometryTrackingConnection = connect(this, &X11Client::frameGeometryChanged, this, [this, border](){
                 hideClient(true);
                 ScreenEdges::self()->reserve(this, border);
             });
         }
 
         if (successfullyHidden) {
             ScreenEdges::self()->reserve(this, border);
         } else {
             ScreenEdges::self()->reserve(this, ElectricNone);
         }
     } else if (!property.isNull() && property->type != XCB_ATOM_NONE) {
         // property value is incorrect, delete the property
         // so that the client knows that it is not hidden
         xcb_delete_property(connection(), window(), atoms->kde_screen_edge_show);
     } else {
         // restore
         // TODO: add proper unreserve
 
         //this will call showOnScreenEdge to reset the state
         disconnect(m_edgeGeometryTrackingConnection);
         ScreenEdges::self()->reserve(this, ElectricNone);
     }
 }
 
 void X11Client::updateShowOnScreenEdge()
 {
     Xcb::Property property = fetchShowOnScreenEdge();
     readShowOnScreenEdge(property);
 }
 
 void X11Client::showOnScreenEdge()
 {
     disconnect(m_edgeRemoveConnection);
 
     hideClient(false);
     setKeepBelow(false);
     xcb_delete_property(connection(), window(), atoms->kde_screen_edge_show);
 }
 
 void X11Client::addDamage(const QRegion &damage)
 {
     if (!ready_for_painting) { // avoid "setReadyForPainting()" function calling overhead
         if (m_syncRequest.counter == XCB_NONE) {  // cannot detect complete redraw, consider done now
             setReadyForPainting();
             setupWindowManagementInterface();
         }
     }
     repaints_region += damage.translated(bufferGeometry().topLeft() - frameGeometry().topLeft());
     Toplevel::addDamage(damage);
 }
 
 bool X11Client::belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const
 {
     const X11Client *c2 = dynamic_cast<const X11Client *>(other);
     if (!c2) {
         return false;
     }
     return X11Client::belongToSameApplication(this, c2, checks);
 }
 
 QSize X11Client::resizeIncrements() const
 {
     return m_geometryHints.resizeIncrements();
 }
 
 Xcb::StringProperty X11Client::fetchApplicationMenuServiceName() const
 {
     return Xcb::StringProperty(m_client, atoms->kde_net_wm_appmenu_service_name);
 }
 
 void X11Client::readApplicationMenuServiceName(Xcb::StringProperty &property)
 {
     updateApplicationMenuServiceName(QString::fromUtf8(property));
 }
 
 void X11Client::checkApplicationMenuServiceName()
 {
     Xcb::StringProperty property = fetchApplicationMenuServiceName();
     readApplicationMenuServiceName(property);
 }
 
 Xcb::StringProperty X11Client::fetchApplicationMenuObjectPath() const
 {
     return Xcb::StringProperty(m_client, atoms->kde_net_wm_appmenu_object_path);
 }
 
 void X11Client::readApplicationMenuObjectPath(Xcb::StringProperty &property)
 {
     updateApplicationMenuObjectPath(QString::fromUtf8(property));
 }
 
 void X11Client::checkApplicationMenuObjectPath()
 {
     Xcb::StringProperty property = fetchApplicationMenuObjectPath();
     readApplicationMenuObjectPath(property);
 }
 
 void X11Client::handleSync()
 {
     setReadyForPainting();
     setupWindowManagementInterface();
     m_syncRequest.isPending = false;
     if (m_syncRequest.failsafeTimeout) {
         m_syncRequest.failsafeTimeout->stop();
     }
     if (isResize()) {
         if (m_syncRequest.timeout) {
             m_syncRequest.timeout->stop();
         }
         performMoveResize();
         updateWindowPixmap();
     } else // setReadyForPainting does as well, but there's a small chance for resize syncs after the resize ended
         addRepaintFull();
 }
 
 void X11Client::move(int x, int y, ForceGeometry_t force)
 {
     const QPoint framePosition(x, y);
     m_clientGeometry.moveTopLeft(framePosToClientPos(framePosition));
     const QPoint bufferPosition = isDecorated() ? framePosition : m_clientGeometry.topLeft();
     // resuming geometry updates is handled only in setGeometry()
     Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
     if (!areGeometryUpdatesBlocked() && framePosition != rules()->checkPosition(framePosition)) {
         qCDebug(KWIN_CORE) << "forced position fail:" << framePosition << ":" << rules()->checkPosition(framePosition);
     }
     m_frameGeometry.moveTopLeft(framePosition);
     if (force == NormalGeometrySet && m_bufferGeometry.topLeft() == bufferPosition) {
         return;
     }
     m_bufferGeometry.moveTopLeft(bufferPosition);
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced) {
             // Maximum, nothing needed.
         } else if (force == ForceGeometrySet) {
             setPendingGeometryUpdate(PendingGeometryForced);
         } else {
             setPendingGeometryUpdate(PendingGeometryNormal);
         }
         return;
     }
     updateServerGeometry();
     updateWindowRules(Rules::Position);
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
     // client itself is not damaged
     if (frameGeometryBeforeUpdateBlocking() != frameGeometry()) {
         emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     }
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 bool X11Client::belongToSameApplication(const X11Client *c1, const X11Client *c2, SameApplicationChecks checks)
 {
     bool same_app = false;
 
     // tests that definitely mean they belong together
     if (c1 == c2)
         same_app = true;
     else if (c1->isTransient() && c2->hasTransient(c1, true))
         same_app = true; // c1 has c2 as mainwindow
     else if (c2->isTransient() && c1->hasTransient(c2, true))
         same_app = true; // c2 has c1 as mainwindow
     else if (c1->group() == c2->group())
         same_app = true; // same group
     else if (c1->wmClientLeader() == c2->wmClientLeader()
             && c1->wmClientLeader() != c1->window() // if WM_CLIENT_LEADER is not set, it returns window(),
             && c2->wmClientLeader() != c2->window()) // don't use in this test then
         same_app = true; // same client leader
 
     // tests that mean they most probably don't belong together
     else if ((c1->pid() != c2->pid() && !checks.testFlag(SameApplicationCheck::AllowCrossProcesses))
             || c1->wmClientMachine(false) != c2->wmClientMachine(false))
         ; // different processes
     else if (c1->wmClientLeader() != c2->wmClientLeader()
             && c1->wmClientLeader() != c1->window() // if WM_CLIENT_LEADER is not set, it returns window(),
             && c2->wmClientLeader() != c2->window() // don't use in this test then
             && !checks.testFlag(SameApplicationCheck::AllowCrossProcesses))
         ; // different client leader
     else if (!resourceMatch(c1, c2))
         ; // different apps
     else if (!sameAppWindowRoleMatch(c1, c2, checks.testFlag(SameApplicationCheck::RelaxedForActive))
             && !checks.testFlag(SameApplicationCheck::AllowCrossProcesses))
         ; // "different" apps
     else if (c1->pid() == 0 || c2->pid() == 0)
         ; // old apps that don't have _NET_WM_PID, consider them different
     // if they weren't found to match above
     else
         same_app = true; // looks like it's the same app
 
     return same_app;
 }
 
 // Non-transient windows with window role containing '#' are always
 // considered belonging to different applications (unless
 // the window role is exactly the same). KMainWindow sets
 // window role this way by default, and different KMainWindow
 // usually "are" different application from user's point of view.
 // This help with no-focus-stealing for e.g. konqy reusing.
 // On the other hand, if one of the windows is active, they are
 // considered belonging to the same application. This is for
 // the cases when opening new mainwindow directly from the application,
 // e.g. 'Open New Window' in konqy ( active_hack == true ).
 bool X11Client::sameAppWindowRoleMatch(const X11Client *c1, const X11Client *c2, bool active_hack)
 {
     if (c1->isTransient()) {
         while (const X11Client *t = dynamic_cast<const X11Client *>(c1->transientFor()))
             c1 = t;
         if (c1->groupTransient())
             return c1->group() == c2->group();
 #if 0
         // if a group transient is in its own group, it didn't possibly have a group,
         // and therefore should be considered belonging to the same app like
         // all other windows from the same app
         || c1->group()->leaderClient() == c1 || c2->group()->leaderClient() == c2;
 #endif
     }
     if (c2->isTransient()) {
         while (const X11Client *t = dynamic_cast<const X11Client *>(c2->transientFor()))
             c2 = t;
         if (c2->groupTransient())
             return c1->group() == c2->group();
 #if 0
         || c1->group()->leaderClient() == c1 || c2->group()->leaderClient() == c2;
 #endif
     }
     int pos1 = c1->windowRole().indexOf('#');
     int pos2 = c2->windowRole().indexOf('#');
     if ((pos1 >= 0 && pos2 >= 0)) {
         if (!active_hack)     // without the active hack for focus stealing prevention,
             return c1 == c2; // different mainwindows are always different apps
         if (!c1->isActive() && !c2->isActive())
             return c1 == c2;
         else
             return true;
     }
     return true;
 }
 
 /*
 
  Transiency stuff: ICCCM 4.1.2.6, NETWM 7.3
 
  WM_TRANSIENT_FOR is basically means "this is my mainwindow".
  For NET::Unknown windows, transient windows are considered to be NET::Dialog
  windows, for compatibility with non-NETWM clients. KWin may adjust the value
  of this property in some cases (window pointing to itself or creating a loop,
  keeping NET::Splash windows above other windows from the same app, etc.).
 
  X11Client::transient_for_id is the value of the WM_TRANSIENT_FOR property, after
  possibly being adjusted by KWin. X11Client::transient_for points to the Client
  this Client is transient for, or is NULL. If X11Client::transient_for_id is
  poiting to the root window, the window is considered to be transient
  for the whole window group, as suggested in NETWM 7.3.
 
  In the case of group transient window, X11Client::transient_for is NULL,
  and X11Client::groupTransient() returns true. Such window is treated as
  if it were transient for every window in its window group that has been
  mapped _before_ it (or, to be exact, was added to the same group before it).
  Otherwise two group transients can create loops, which can lead very very
  nasty things (bug #67914 and all its dupes).
 
  X11Client::original_transient_for_id is the value of the property, which
  may be different if X11Client::transient_for_id if e.g. forcing NET::Splash
  to be kept on top of its window group, or when the mainwindow is not mapped
  yet, in which case the window is temporarily made group transient,
  and when the mainwindow is mapped, transiency is re-evaluated.
 
  This can get a bit complicated with with e.g. two Konqueror windows created
  by the same process. They should ideally appear like two independent applications
  to the user. This should be accomplished by all windows in the same process
  having the same window group (needs to be changed in Qt at the moment), and
  using non-group transients poiting to their relevant mainwindow for toolwindows
  etc. KWin should handle both group and non-group transient dialogs well.
 
  In other words:
  - non-transient windows     : isTransient() == false
  - normal transients         : transientFor() != NULL
  - group transients          : groupTransient() == true
 
  - list of mainwindows       : mainClients()  (call once and loop over the result)
  - list of transients        : transients()
  - every window in the group : group()->members()
 */
 
 Xcb::TransientFor X11Client::fetchTransient() const
 {
     return Xcb::TransientFor(window());
 }
 
 void X11Client::readTransientProperty(Xcb::TransientFor &transientFor)
 {
     xcb_window_t new_transient_for_id = XCB_WINDOW_NONE;
     if (transientFor.getTransientFor(&new_transient_for_id)) {
         m_originalTransientForId = new_transient_for_id;
         new_transient_for_id = verifyTransientFor(new_transient_for_id, true);
     } else {
         m_originalTransientForId = XCB_WINDOW_NONE;
         new_transient_for_id = verifyTransientFor(XCB_WINDOW_NONE, false);
     }
     setTransient(new_transient_for_id);
 }
 
 void X11Client::readTransient()
 {
     Xcb::TransientFor transientFor = fetchTransient();
     readTransientProperty(transientFor);
 }
 
 void X11Client::setTransient(xcb_window_t new_transient_for_id)
 {
     if (new_transient_for_id != m_transientForId) {
         removeFromMainClients();
         X11Client *transient_for = nullptr;
         m_transientForId = new_transient_for_id;
         if (m_transientForId != XCB_WINDOW_NONE && !groupTransient()) {
             transient_for = workspace()->findClient(Predicate::WindowMatch, m_transientForId);
             Q_ASSERT(transient_for != nullptr);   // verifyTransient() had to check this
             transient_for->addTransient(this);
         } // checkGroup() will check 'check_active_modal'
         setTransientFor(transient_for);
         checkGroup(nullptr, true);   // force, because transiency has changed
         workspace()->updateClientLayer(this);
         workspace()->resetUpdateToolWindowsTimer();
         emit transientChanged();
     }
 }
 
 void X11Client::removeFromMainClients()
 {
     if (transientFor())
         transientFor()->removeTransient(this);
     if (groupTransient()) {
         for (auto it = group()->members().constBegin();
                 it != group()->members().constEnd();
                 ++it)
             (*it)->removeTransient(this);
     }
 }
 
 // *sigh* this transiency handling is madness :(
 // This one is called when destroying/releasing a window.
 // It makes sure this client is removed from all grouping
 // related lists.
 void X11Client::cleanGrouping()
 {
 //    qDebug() << "CLEANGROUPING:" << this;
 //    for ( auto it = group()->members().begin();
 //         it != group()->members().end();
 //         ++it )
 //        qDebug() << "CL:" << *it;
 //    QList<X11Client *> mains;
 //    mains = mainClients();
 //    for ( auto it = mains.begin();
 //         it != mains.end();
 //         ++it )
 //        qDebug() << "MN:" << *it;
     removeFromMainClients();
 //    qDebug() << "CLEANGROUPING2:" << this;
 //    for ( auto it = group()->members().begin();
 //         it != group()->members().end();
 //         ++it )
 //        qDebug() << "CL2:" << *it;
 //    mains = mainClients();
 //    for ( auto it = mains.begin();
 //         it != mains.end();
 //         ++it )
 //        qDebug() << "MN2:" << *it;
     for (auto it = transients().constBegin();
             it != transients().constEnd();
        ) {
         if ((*it)->transientFor() == this) {
             removeTransient(*it);
             it = transients().constBegin(); // restart, just in case something more has changed with the list
         } else
             ++it;
     }
 //    qDebug() << "CLEANGROUPING3:" << this;
 //    for ( auto it = group()->members().begin();
 //         it != group()->members().end();
 //         ++it )
 //        qDebug() << "CL3:" << *it;
 //    mains = mainClients();
 //    for ( auto it = mains.begin();
 //         it != mains.end();
 //         ++it )
 //        qDebug() << "MN3:" << *it;
     // HACK
     // removeFromMainClients() did remove 'this' from transient
     // lists of all group members, but then made windows that
     // were transient for 'this' group transient, which again
     // added 'this' to those transient lists :(
     QList<X11Client *> group_members = group()->members();
     group()->removeMember(this);
     in_group = nullptr;
     for (auto it = group_members.constBegin();
             it != group_members.constEnd();
             ++it)
         (*it)->removeTransient(this);
 //    qDebug() << "CLEANGROUPING4:" << this;
 //    for ( auto it = group_members.begin();
 //         it != group_members.end();
 //         ++it )
 //        qDebug() << "CL4:" << *it;
     m_transientForId = XCB_WINDOW_NONE;
 }
 
 // Make sure that no group transient is considered transient
 // for a window that is (directly or indirectly) transient for it
 // (including another group transients).
 // Non-group transients not causing loops are checked in verifyTransientFor().
 void X11Client::checkGroupTransients()
 {
     for (auto it1 = group()->members().constBegin();
             it1 != group()->members().constEnd();
             ++it1) {
         if (!(*it1)->groupTransient())  // check all group transients in the group
             continue;                  // TODO optimize to check only the changed ones?
         for (auto it2 = group()->members().constBegin();
                 it2 != group()->members().constEnd();
                 ++it2) { // group transients can be transient only for others in the group,
             // so don't make them transient for the ones that are transient for it
             if (*it1 == *it2)
                 continue;
             for (AbstractClient* cl = (*it2)->transientFor();
                     cl != nullptr;
                     cl = cl->transientFor()) {
                 if (cl == *it1) {
                     // don't use removeTransient(), that would modify *it2 too
                     (*it2)->removeTransientFromList(*it1);
                     continue;
                 }
             }
             // if *it1 and *it2 are both group transients, and are transient for each other,
             // make only *it2 transient for *it1 (i.e. subwindow), as *it2 came later,
             // and should be therefore on top of *it1
             // TODO This could possibly be optimized, it also requires hasTransient() to check for loops.
             if ((*it2)->groupTransient() && (*it1)->hasTransient(*it2, true) && (*it2)->hasTransient(*it1, true))
                 (*it2)->removeTransientFromList(*it1);
             // if there are already windows W1 and W2, W2 being transient for W1, and group transient W3
             // is added, make it transient only for W2, not for W1, because it's already indirectly
             // transient for it - the indirect transiency actually shouldn't break anything,
             // but it can lead to exponentially expensive operations (#95231)
             // TODO this is pretty slow as well
             for (auto it3 = group()->members().constBegin();
                     it3 != group()->members().constEnd();
                     ++it3) {
                 if (*it1 == *it2 || *it2 == *it3 || *it1 == *it3)
                     continue;
                 if ((*it2)->hasTransient(*it1, false) && (*it3)->hasTransient(*it1, false)) {
                     if ((*it2)->hasTransient(*it3, true))
                         (*it2)->removeTransientFromList(*it1);
                     if ((*it3)->hasTransient(*it2, true))
                         (*it3)->removeTransientFromList(*it1);
                 }
             }
         }
     }
 }
 
 /**
  * Check that the window is not transient for itself, and similar nonsense.
  */
 xcb_window_t X11Client::verifyTransientFor(xcb_window_t new_transient_for, bool set)
 {
     xcb_window_t new_property_value = new_transient_for;
     // make sure splashscreens are shown above all their app's windows, even though
     // they're in Normal layer
     if (isSplash() && new_transient_for == XCB_WINDOW_NONE)
         new_transient_for = rootWindow();
     if (new_transient_for == XCB_WINDOW_NONE) {
         if (set)   // sometimes WM_TRANSIENT_FOR is set to None, instead of root window
             new_property_value = new_transient_for = rootWindow();
         else
             return XCB_WINDOW_NONE;
     }
     if (new_transient_for == window()) { // pointing to self
         // also fix the property itself
         qCWarning(KWIN_CORE) << "Client " << this << " has WM_TRANSIENT_FOR poiting to itself." ;
         new_property_value = new_transient_for = rootWindow();
     }
 //  The transient_for window may be embedded in another application,
 //  so kwin cannot see it. Try to find the managed client for the
 //  window and fix the transient_for property if possible.
     xcb_window_t before_search = new_transient_for;
     while (new_transient_for != XCB_WINDOW_NONE
             && new_transient_for != rootWindow()
             && !workspace()->findClient(Predicate::WindowMatch, new_transient_for)) {
         Xcb::Tree tree(new_transient_for);
         if (tree.isNull()) {
             break;
         }
         new_transient_for = tree->parent;
     }
     if (X11Client *new_transient_for_client = workspace()->findClient(Predicate::WindowMatch, new_transient_for)) {
         if (new_transient_for != before_search) {
             qCDebug(KWIN_CORE) << "Client " << this << " has WM_TRANSIENT_FOR poiting to non-toplevel window "
                          << before_search << ", child of " << new_transient_for_client << ", adjusting.";
             new_property_value = new_transient_for; // also fix the property
         }
     } else
         new_transient_for = before_search; // nice try
 // loop detection
 // group transients cannot cause loops, because they're considered transient only for non-transient
 // windows in the group
     int count = 20;
     xcb_window_t loop_pos = new_transient_for;
     while (loop_pos != XCB_WINDOW_NONE && loop_pos != rootWindow()) {
         X11Client *pos = workspace()->findClient(Predicate::WindowMatch, loop_pos);
         if (pos == nullptr)
             break;
         loop_pos = pos->m_transientForId;
         if (--count == 0 || pos == this) {
             qCWarning(KWIN_CORE) << "Client " << this << " caused WM_TRANSIENT_FOR loop." ;
             new_transient_for = rootWindow();
         }
     }
     if (new_transient_for != rootWindow()
             && workspace()->findClient(Predicate::WindowMatch, new_transient_for) == nullptr) {
         // it's transient for a specific window, but that window is not mapped
         new_transient_for = rootWindow();
     }
     if (new_property_value != m_originalTransientForId)
         Xcb::setTransientFor(window(), new_property_value);
     return new_transient_for;
 }
 
 void X11Client::addTransient(AbstractClient* cl)
 {
     AbstractClient::addTransient(cl);
     if (workspace()->mostRecentlyActivatedClient() == this && cl->isModal())
         check_active_modal = true;
 //    qDebug() << "ADDTRANS:" << this << ":" << cl;
 //    qDebug() << kBacktrace();
 //    for ( auto it = transients_list.begin();
 //         it != transients_list.end();
 //         ++it )
 //        qDebug() << "AT:" << (*it);
 }
 
 void X11Client::removeTransient(AbstractClient* cl)
 {
 //    qDebug() << "REMOVETRANS:" << this << ":" << cl;
 //    qDebug() << kBacktrace();
     // cl is transient for this, but this is going away
     // make cl group transient
     AbstractClient::removeTransient(cl);
     if (cl->transientFor() == this) {
         if (X11Client *c = dynamic_cast<X11Client *>(cl)) {
             c->m_transientForId = XCB_WINDOW_NONE;
             c->setTransientFor(nullptr); // SELI
 // SELI       cl->setTransient( rootWindow());
             c->setTransient(XCB_WINDOW_NONE);
         }
     }
 }
 
 // A new window has been mapped. Check if it's not a mainwindow for this already existing window.
 void X11Client::checkTransient(xcb_window_t w)
 {
     if (m_originalTransientForId != w)
         return;
     w = verifyTransientFor(w, true);
     setTransient(w);
 }
 
 // returns true if cl is the transient_for window for this client,
 // or recursively the transient_for window
 bool X11Client::hasTransient(const AbstractClient* cl, bool indirect) const
 {
     if (const X11Client *c = dynamic_cast<const X11Client *>(cl)) {
         // checkGroupTransients() uses this to break loops, so hasTransient() must detect them
         QList<const X11Client *> set;
         return hasTransientInternal(c, indirect, set);
     }
     return false;
 }
 
 bool X11Client::hasTransientInternal(const X11Client *cl, bool indirect, QList<const X11Client *> &set) const
 {
     if (const X11Client *t = dynamic_cast<const X11Client *>(cl->transientFor())) {
         if (t == this)
             return true;
         if (!indirect)
             return false;
         if (set.contains(cl))
             return false;
         set.append(cl);
         return hasTransientInternal(t, indirect, set);
     }
     if (!cl->isTransient())
         return false;
     if (group() != cl->group())
         return false;
     // cl is group transient, search from top
     if (transients().contains(const_cast< X11Client *>(cl)))
         return true;
     if (!indirect)
         return false;
     if (set.contains(this))
         return false;
     set.append(this);
     for (auto it = transients().constBegin();
             it != transients().constEnd();
             ++it) {
         const X11Client *c = qobject_cast<const X11Client *>(*it);
         if (!c) {
             continue;
         }
         if (c->hasTransientInternal(cl, indirect, set))
             return true;
     }
     return false;
 }
 
 QList<AbstractClient*> X11Client::mainClients() const
 {
     if (!isTransient())
         return QList<AbstractClient*>();
     if (const AbstractClient *t = transientFor())
         return QList<AbstractClient*>{const_cast< AbstractClient* >(t)};
     QList<AbstractClient*> result;
     Q_ASSERT(group());
     for (auto it = group()->members().constBegin();
             it != group()->members().constEnd();
             ++it)
         if ((*it)->hasTransient(this, false))
             result.append(*it);
     return result;
 }
 
 AbstractClient* X11Client::findModal(bool allow_itself)
 {
     for (auto it = transients().constBegin();
             it != transients().constEnd();
             ++it)
         if (AbstractClient* ret = (*it)->findModal(true))
             return ret;
     if (isModal() && allow_itself)
         return this;
     return nullptr;
 }
 
 // X11Client::window_group only holds the contents of the hint,
 // but it should be used only to find the group, not for anything else
 // Argument is only when some specific group needs to be set.
 void X11Client::checkGroup(Group* set_group, bool force)
 {
     Group* old_group = in_group;
     if (old_group != nullptr)
         old_group->ref(); // turn off automatic deleting
     if (set_group != nullptr) {
         if (set_group != in_group) {
             if (in_group != nullptr)
                 in_group->removeMember(this);
             in_group = set_group;
             in_group->addMember(this);
         }
     } else if (info->groupLeader() != XCB_WINDOW_NONE) {
         Group* new_group = workspace()->findGroup(info->groupLeader());
         X11Client *t = qobject_cast<X11Client *>(transientFor());
         if (t != nullptr && t->group() != new_group) {
             // move the window to the right group (e.g. a dialog provided
             // by different app, but transient for this one, so make it part of that group)
             new_group = t->group();
         }
         if (new_group == nullptr)   // doesn't exist yet
             new_group = new Group(info->groupLeader());
         if (new_group != in_group) {
             if (in_group != nullptr)
                 in_group->removeMember(this);
             in_group = new_group;
             in_group->addMember(this);
         }
     } else {
         if (X11Client *t = qobject_cast<X11Client *>(transientFor())) {
             // doesn't have window group set, but is transient for something
             // so make it part of that group
             Group* new_group = t->group();
             if (new_group != in_group) {
                 if (in_group != nullptr)
                     in_group->removeMember(this);
                 in_group = t->group();
                 in_group->addMember(this);
             }
         } else if (groupTransient()) {
             // group transient which actually doesn't have a group :(
             // try creating group with other windows with the same client leader
             Group* new_group = workspace()->findClientLeaderGroup(this);
             if (new_group == nullptr)
                 new_group = new Group(XCB_WINDOW_NONE);
             if (new_group != in_group) {
                 if (in_group != nullptr)
                     in_group->removeMember(this);
                 in_group = new_group;
                 in_group->addMember(this);
             }
         } else { // Not transient without a group, put it in its client leader group.
             // This might be stupid if grouping was used for e.g. taskbar grouping
             // or minimizing together the whole group, but as long as it is used
             // only for dialogs it's better to keep windows from one app in one group.
             Group* new_group = workspace()->findClientLeaderGroup(this);
             if (in_group != nullptr && in_group != new_group) {
                 in_group->removeMember(this);
                 in_group = nullptr;
             }
             if (new_group == nullptr)
                 new_group = new Group(XCB_WINDOW_NONE);
             if (in_group != new_group) {
                 in_group = new_group;
                 in_group->addMember(this);
             }
         }
     }
     if (in_group != old_group || force) {
         for (auto it = transients().constBegin();
                 it != transients().constEnd();
            ) {
             auto *c = *it;
             // group transients in the old group are no longer transient for it
             if (c->groupTransient() && c->group() != group()) {
                 removeTransientFromList(c);
                 it = transients().constBegin(); // restart, just in case something more has changed with the list
             } else
                 ++it;
         }
         if (groupTransient()) {
             // no longer transient for ones in the old group
             if (old_group != nullptr) {
                 for (auto it = old_group->members().constBegin();
                         it != old_group->members().constEnd();
                         ++it)
                     (*it)->removeTransient(this);
             }
             // and make transient for all in the new group
             for (auto it = group()->members().constBegin();
                     it != group()->members().constEnd();
                     ++it) {
                 if (*it == this)
                     break; // this means the window is only transient for windows mapped before it
                 (*it)->addTransient(this);
             }
         }
         // group transient splashscreens should be transient even for windows
         // in group mapped later
         for (auto it = group()->members().constBegin();
                 it != group()->members().constEnd();
                 ++it) {
             if (!(*it)->isSplash())
                 continue;
             if (!(*it)->groupTransient())
                 continue;
             if (*it == this || hasTransient(*it, true))    // TODO indirect?
                 continue;
             addTransient(*it);
         }
     }
     if (old_group != nullptr)
         old_group->deref(); // can be now deleted if empty
     checkGroupTransients();
     checkActiveModal();
     workspace()->updateClientLayer(this);
 }
 
 // used by Workspace::findClientLeaderGroup()
 void X11Client::changeClientLeaderGroup(Group* gr)
 {
     // transientFor() != NULL are in the group of their mainwindow, so keep them there
     if (transientFor() != nullptr)
         return;
     // also don't change the group for window which have group set
     if (info->groupLeader())
         return;
     checkGroup(gr);   // change group
 }
 
 bool X11Client::check_active_modal = false;
 
 void X11Client::checkActiveModal()
 {
     // if the active window got new modal transient, activate it.
     // cannot be done in AddTransient(), because there may temporarily
     // exist loops, breaking findModal
     X11Client *check_modal = dynamic_cast<X11Client *>(workspace()->mostRecentlyActivatedClient());
     if (check_modal != nullptr && check_modal->check_active_modal) {
         X11Client *new_modal = dynamic_cast<X11Client *>(check_modal->findModal());
         if (new_modal != nullptr && new_modal != check_modal) {
             if (!new_modal->isManaged())
                 return; // postpone check until end of manage()
             workspace()->activateClient(new_modal);
         }
         check_modal->check_active_modal = false;
     }
 }
 
 QSize X11Client::constrainClientSize(const QSize &size, SizeMode mode) const
 {
     int w = size.width();
     int h = size.height();
 
     if (w < 1) w = 1;
     if (h < 1) h = 1;
 
     // basesize, minsize, maxsize, paspect and resizeinc have all values defined,
     // even if they're not set in flags - see getWmNormalHints()
     QSize min_size = minSize();
     QSize max_size = maxSize();
     if (isDecorated()) {
         QSize decominsize(0, 0);
         QSize border_size(borderLeft() + borderRight(), borderTop() + borderBottom());
         if (border_size.width() > decominsize.width())  // just in case
             decominsize.setWidth(border_size.width());
         if (border_size.height() > decominsize.height())
             decominsize.setHeight(border_size.height());
         if (decominsize.width() > min_size.width())
             min_size.setWidth(decominsize.width());
         if (decominsize.height() > min_size.height())
             min_size.setHeight(decominsize.height());
     }
     w = qMin(max_size.width(), w);
     h = qMin(max_size.height(), h);
     w = qMax(min_size.width(), w);
     h = qMax(min_size.height(), h);
 
     if (!rules()->checkStrictGeometry(!isFullScreen())) {
         // Disobey increments and aspect by explicit rule.
         return QSize(w, h);
     }
 
     int width_inc = m_geometryHints.resizeIncrements().width();
     int height_inc = m_geometryHints.resizeIncrements().height();
     int basew_inc = m_geometryHints.baseSize().width();
     int baseh_inc = m_geometryHints.baseSize().height();
     if (!m_geometryHints.hasBaseSize()) {
         basew_inc = m_geometryHints.minSize().width();
         baseh_inc = m_geometryHints.minSize().height();
     }
     w = int((w - basew_inc) / width_inc) * width_inc + basew_inc;
     h = int((h - baseh_inc) / height_inc) * height_inc + baseh_inc;
 // code for aspect ratios based on code from FVWM
     /*
      * The math looks like this:
      *
      * minAspectX    dwidth     maxAspectX
      * ---------- <= ------- <= ----------
      * minAspectY    dheight    maxAspectY
      *
      * If that is multiplied out, then the width and height are
      * invalid in the following situations:
      *
      * minAspectX * dheight > minAspectY * dwidth
      * maxAspectX * dheight < maxAspectY * dwidth
      *
      */
     if (m_geometryHints.hasAspect()) {
         double min_aspect_w = m_geometryHints.minAspect().width(); // use doubles, because the values can be MAX_INT
         double min_aspect_h = m_geometryHints.minAspect().height(); // and multiplying would go wrong otherwise
         double max_aspect_w = m_geometryHints.maxAspect().width();
         double max_aspect_h = m_geometryHints.maxAspect().height();
         // According to ICCCM 4.1.2.3 PMinSize should be a fallback for PBaseSize for size increments,
         // but not for aspect ratio. Since this code comes from FVWM, handles both at the same time,
         // and I have no idea how it works, let's hope nobody relies on that.
         const QSize baseSize = m_geometryHints.baseSize();
         w -= baseSize.width();
         h -= baseSize.height();
         int max_width = max_size.width() - baseSize.width();
         int min_width = min_size.width() - baseSize.width();
         int max_height = max_size.height() - baseSize.height();
         int min_height = min_size.height() - baseSize.height();
 #define ASPECT_CHECK_GROW_W \
     if ( min_aspect_w * h > min_aspect_h * w ) \
     { \
         int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
         if ( w + delta <= max_width ) \
             w += delta; \
     }
 #define ASPECT_CHECK_SHRINK_H_GROW_W \
     if ( min_aspect_w * h > min_aspect_h * w ) \
     { \
         int delta = int( h - w * min_aspect_h / min_aspect_w ) / height_inc * height_inc; \
         if ( h - delta >= min_height ) \
             h -= delta; \
         else \
         { \
             int delta = int( min_aspect_w * h / min_aspect_h - w ) / width_inc * width_inc; \
             if ( w + delta <= max_width ) \
                 w += delta; \
         } \
     }
 #define ASPECT_CHECK_GROW_H \
     if ( max_aspect_w * h < max_aspect_h * w ) \
     { \
         int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
         if ( h + delta <= max_height ) \
             h += delta; \
     }
 #define ASPECT_CHECK_SHRINK_W_GROW_H \
     if ( max_aspect_w * h < max_aspect_h * w ) \
     { \
         int delta = int( w - max_aspect_w * h / max_aspect_h ) / width_inc * width_inc; \
         if ( w - delta >= min_width ) \
             w -= delta; \
         else \
         { \
             int delta = int( w * max_aspect_h / max_aspect_w - h ) / height_inc * height_inc; \
             if ( h + delta <= max_height ) \
                 h += delta; \
         } \
     }
         switch(mode) {
         case SizeModeAny:
 #if 0 // make SizeModeAny equal to SizeModeFixedW - prefer keeping fixed width,
             // so that changing aspect ratio to a different value and back keeps the same size (#87298)
             {
                 ASPECT_CHECK_SHRINK_H_GROW_W
                 ASPECT_CHECK_SHRINK_W_GROW_H
                 ASPECT_CHECK_GROW_H
                 ASPECT_CHECK_GROW_W
                 break;
             }
 #endif
         case SizeModeFixedW: {
             // the checks are order so that attempts to modify height are first
             ASPECT_CHECK_GROW_H
             ASPECT_CHECK_SHRINK_H_GROW_W
             ASPECT_CHECK_SHRINK_W_GROW_H
             ASPECT_CHECK_GROW_W
             break;
         }
         case SizeModeFixedH: {
             ASPECT_CHECK_GROW_W
             ASPECT_CHECK_SHRINK_W_GROW_H
             ASPECT_CHECK_SHRINK_H_GROW_W
             ASPECT_CHECK_GROW_H
             break;
         }
         case SizeModeMax: {
             // first checks that try to shrink
             ASPECT_CHECK_SHRINK_H_GROW_W
             ASPECT_CHECK_SHRINK_W_GROW_H
             ASPECT_CHECK_GROW_W
             ASPECT_CHECK_GROW_H
             break;
         }
         }
 #undef ASPECT_CHECK_SHRINK_H_GROW_W
 #undef ASPECT_CHECK_SHRINK_W_GROW_H
 #undef ASPECT_CHECK_GROW_W
 #undef ASPECT_CHECK_GROW_H
         w += baseSize.width();
         h += baseSize.height();
     }
 
     return QSize(w, h);
 }
 
 /**
  * Gets the client's normal WM hints and reconfigures itself respectively.
  */
 void X11Client::getWmNormalHints()
 {
     const bool hadFixedAspect = m_geometryHints.hasAspect();
     // roundtrip to X server
     m_geometryHints.fetch();
     m_geometryHints.read();
 
     if (!hadFixedAspect && m_geometryHints.hasAspect()) {
         // align to eventual new constraints
         maximize(max_mode);
     }
     if (isManaged()) {
         // update to match restrictions
         QSize new_size = adjustedSize();
         if (new_size != size() && !isFullScreen()) {
             QRect origClientGeometry = m_clientGeometry;
             resizeWithChecks(new_size);
             if ((!isSpecialWindow() || isToolbar()) && !isFullScreen()) {
                 // try to keep the window in its xinerama screen if possible,
                 // if that fails at least keep it visible somewhere
                 QRect area = workspace()->clientArea(MovementArea, this);
                 if (area.contains(origClientGeometry))
                     keepInArea(area);
                 area = workspace()->clientArea(WorkArea, this);
                 if (area.contains(origClientGeometry))
                     keepInArea(area);
             }
         }
     }
     updateAllowedActions(); // affects isResizeable()
 }
 
 QSize X11Client::minSize() const
 {
     return rules()->checkMinSize(m_geometryHints.minSize());
 }
 
 QSize X11Client::maxSize() const
 {
     return rules()->checkMaxSize(m_geometryHints.maxSize());
 }
 
 QSize X11Client::basicUnit() const
 {
     return m_geometryHints.resizeIncrements();
 }
 
 /**
  * Auxiliary function to inform the client about the current window
  * configuration.
  */
 void X11Client::sendSyntheticConfigureNotify()
 {
     xcb_configure_notify_event_t c;
     memset(&c, 0, sizeof(c));
     c.response_type = XCB_CONFIGURE_NOTIFY;
     c.event = window();
     c.window = window();
     c.x = m_clientGeometry.x();
     c.y = m_clientGeometry.y();
     c.width = m_clientGeometry.width();
     c.height = m_clientGeometry.height();
     c.border_width = 0;
     c.above_sibling = XCB_WINDOW_NONE;
     c.override_redirect = 0;
     xcb_send_event(connection(), true, c.event, XCB_EVENT_MASK_STRUCTURE_NOTIFY, reinterpret_cast<const char*>(&c));
     xcb_flush(connection());
 }
 
 QPoint X11Client::gravityAdjustment(xcb_gravity_t gravity) const
 {
     int dx = 0;
     int dy = 0;
 
     // dx, dy specify how the client window moves to make space for the frame.
     // In general we have to compute the reference point and from that figure
     // out how much we need to shift the client, however given that we ignore
     // the border width attribute and the extents of the server-side decoration
     // are known in advance, we can simplify the math quite a bit and express
     // the required window gravity adjustment in terms of border sizes.
     switch(gravity) {
     case XCB_GRAVITY_NORTH_WEST: // move down right
     default:
         dx = borderLeft();
         dy = borderTop();
         break;
     case XCB_GRAVITY_NORTH: // move right
         dx = 0;
         dy = borderTop();
         break;
     case XCB_GRAVITY_NORTH_EAST: // move down left
         dx = -borderRight();
         dy = borderTop();
         break;
     case XCB_GRAVITY_WEST: // move right
         dx = borderLeft();
         dy = 0;
         break;
     case XCB_GRAVITY_CENTER:
         dx = (borderLeft() - borderRight()) / 2;
         dy = (borderTop() - borderBottom()) / 2;
         break;
     case XCB_GRAVITY_STATIC: // don't move
         dx = 0;
         dy = 0;
         break;
     case XCB_GRAVITY_EAST: // move left
         dx = -borderRight();
         dy = 0;
         break;
     case XCB_GRAVITY_SOUTH_WEST: // move up right
         dx = borderLeft() ;
         dy = -borderBottom();
         break;
     case XCB_GRAVITY_SOUTH: // move up
         dx = 0;
         dy = -borderBottom();
         break;
     case XCB_GRAVITY_SOUTH_EAST: // move up left
         dx = -borderRight();
         dy = -borderBottom();
         break;
     }
 
     return QPoint(dx, dy);
 }
 
 const QPoint X11Client::calculateGravitation(bool invert) const
 {
     const QPoint adjustment = gravityAdjustment(m_geometryHints.windowGravity());
 
     // translate from client movement to frame movement
     const int dx = adjustment.x() - borderLeft();
     const int dy = adjustment.y() - borderTop();
 
     if (!invert)
         return QPoint(x() + dx, y() + dy);
     else
         return QPoint(x() - dx, y() - dy);
 }
 
 void X11Client::configureRequest(int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool)
 {
     const int configurePositionMask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y;
     const int configureSizeMask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
     const int configureGeometryMask = configurePositionMask | configureSizeMask;
 
     // "maximized" is a user setting -> we do not allow the client to resize itself
     // away from this & against the users explicit wish
     qCDebug(KWIN_CORE) << this << bool(value_mask & configureGeometryMask) <<
                             bool(maximizeMode() & MaximizeVertical) <<
                             bool(maximizeMode() & MaximizeHorizontal);
 
     // we want to (partially) ignore the request when the window is somehow maximized or quicktiled
     bool ignore = !app_noborder && (quickTileMode() != QuickTileMode(QuickTileFlag::None) || maximizeMode() != MaximizeRestore);
     // however, the user shall be able to force obedience despite and also disobedience in general
     ignore = rules()->checkIgnoreGeometry(ignore);
     if (!ignore) { // either we're not max'd / q'tiled or the user allowed the client to break that - so break it.
         updateQuickTileMode(QuickTileFlag::None);
         max_mode = MaximizeRestore;
         emit quickTileModeChanged();
     } else if (!app_noborder && quickTileMode() == QuickTileMode(QuickTileFlag::None) &&
         (maximizeMode() == MaximizeVertical || maximizeMode() == MaximizeHorizontal)) {
         // ignoring can be, because either we do, or the user does explicitly not want it.
         // for partially maximized windows we want to allow configures in the other dimension.
         // so we've to ask the user again - to know whether we just ignored for the partial maximization.
         // the problem here is, that the user can explicitly permit configure requests - even for maximized windows!
         // we cannot distinguish that from passing "false" for partially maximized windows.
         ignore = rules()->checkIgnoreGeometry(false);
         if (!ignore) { // the user is not interested, so we fix up dimensions
             if (maximizeMode() == MaximizeVertical)
                 value_mask &= ~(XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT);
             if (maximizeMode() == MaximizeHorizontal)
                 value_mask &= ~(XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_WIDTH);
             if (!(value_mask & configureGeometryMask)) {
                 ignore = true; // the modification turned the request void
             }
         }
     }
 
     if (ignore) {
         qCDebug(KWIN_CORE) << "DENIED";
         return; // nothing to (left) to do for use - bugs #158974, #252314, #321491
     }
 
     qCDebug(KWIN_CORE) << "PERMITTED" << this << bool(value_mask & configureGeometryMask);
 
     if (gravity == 0)   // default (nonsense) value for the argument
         gravity = m_geometryHints.windowGravity();
     if (value_mask & configurePositionMask) {
         QPoint new_pos = framePosToClientPos(pos());
         new_pos -= gravityAdjustment(xcb_gravity_t(gravity));
         if (value_mask & XCB_CONFIG_WINDOW_X) {
             new_pos.setX(rx);
         }
         if (value_mask & XCB_CONFIG_WINDOW_Y) {
             new_pos.setY(ry);
         }
         // clever(?) workaround for applications like xv that want to set
         // the location to the current location but miscalculate the
         // frame size due to kwin being a double-reparenting window
         // manager
         if (new_pos.x() == m_clientGeometry.x() && new_pos.y() == m_clientGeometry.y()
                 && gravity == XCB_GRAVITY_NORTH_WEST && !from_tool) {
             new_pos.setX(x());
             new_pos.setY(y());
         }
         new_pos += gravityAdjustment(xcb_gravity_t(gravity));
         new_pos = clientPosToFramePos(new_pos);
 
         int nw = clientSize().width();
         int nh = clientSize().height();
         if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
             nw = rw;
         }
         if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
             nh = rh;
         }
         const QSize requestedClientSize = constrainClientSize(QSize(nw, nh));
         QSize requestedFrameSize = clientSizeToFrameSize(requestedClientSize);
         requestedFrameSize = rules()->checkSize(requestedFrameSize);
         new_pos = rules()->checkPosition(new_pos);
         int newScreen = screens()->number(QRect(new_pos, requestedFrameSize).center());
         if (newScreen != rules()->checkScreen(newScreen))
             return; // not allowed by rule
 
         QRect origClientGeometry = m_clientGeometry;
         GeometryUpdatesBlocker blocker(this);
         move(new_pos);
         plainResize(requestedFrameSize);
         QRect area = workspace()->clientArea(WorkArea, this);
         if (!from_tool && (!isSpecialWindow() || isToolbar()) && !isFullScreen()
                 && area.contains(origClientGeometry))
             keepInArea(area);
 
         // this is part of the kicker-xinerama-hack... it should be
         // safe to remove when kicker gets proper ExtendedStrut support;
         // see Workspace::updateClientArea() and
         // X11Client::adjustedClientArea()
         if (hasStrut())
             workspace() -> updateClientArea();
     }
 
     if (value_mask & configureSizeMask && !(value_mask & configurePositionMask)) {     // pure resize
         int nw = clientSize().width();
         int nh = clientSize().height();
         if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
             nw = rw;
         }
         if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
             nh = rh;
         }
 
         const QSize requestedClientSize = constrainClientSize(QSize(nw, nh));
         QSize requestedFrameSize = clientSizeToFrameSize(requestedClientSize);
         requestedFrameSize = rules()->checkSize(requestedFrameSize);
 
         if (requestedFrameSize != size()) { // don't restore if some app sets its own size again
             QRect origClientGeometry = m_clientGeometry;
             GeometryUpdatesBlocker blocker(this);
             resizeWithChecks(requestedFrameSize, xcb_gravity_t(gravity));
             if (!from_tool && (!isSpecialWindow() || isToolbar()) && !isFullScreen()) {
                 // try to keep the window in its xinerama screen if possible,
                 // if that fails at least keep it visible somewhere
                 QRect area = workspace()->clientArea(MovementArea, this);
                 if (area.contains(origClientGeometry))
                     keepInArea(area);
                 area = workspace()->clientArea(WorkArea, this);
                 if (area.contains(origClientGeometry))
                     keepInArea(area);
             }
         }
     }
     setGeometryRestore(frameGeometry());
     // No need to send synthetic configure notify event here, either it's sent together
     // with geometry change, or there's no need to send it.
     // Handling of the real ConfigureRequest event forces sending it, as there it's necessary.
 }
 
 void X11Client::resizeWithChecks(int w, int h, xcb_gravity_t gravity, ForceGeometry_t force)
 {
     Q_ASSERT(!shade_geometry_change);
     if (isShade()) {
         if (h == borderTop() + borderBottom()) {
             qCWarning(KWIN_CORE) << "Shaded geometry passed for size:" ;
         }
     }
     int newx = x();
     int newy = y();
     QRect area = workspace()->clientArea(WorkArea, this);
     // don't allow growing larger than workarea
     if (w > area.width())
         w = area.width();
     if (h > area.height())
         h = area.height();
     QSize tmp = constrainFrameSize(QSize(w, h));    // checks size constraints, including min/max size
     w = tmp.width();
     h = tmp.height();
     if (gravity == 0) {
         gravity = m_geometryHints.windowGravity();
     }
     switch(gravity) {
     case XCB_GRAVITY_NORTH_WEST: // top left corner doesn't move
     default:
         break;
     case XCB_GRAVITY_NORTH: // middle of top border doesn't move
         newx = (newx + width() / 2) - (w / 2);
         break;
     case XCB_GRAVITY_NORTH_EAST: // top right corner doesn't move
         newx = newx + width() - w;
         break;
     case XCB_GRAVITY_WEST: // middle of left border doesn't move
         newy = (newy + height() / 2) - (h / 2);
         break;
     case XCB_GRAVITY_CENTER: // middle point doesn't move
         newx = (newx + width() / 2) - (w / 2);
         newy = (newy + height() / 2) - (h / 2);
         break;
     case XCB_GRAVITY_STATIC: // top left corner of _client_ window doesn't move
         // since decoration doesn't change, equal to NorthWestGravity
         break;
     case XCB_GRAVITY_EAST: // // middle of right border doesn't move
         newx = newx + width() - w;
         newy = (newy + height() / 2) - (h / 2);
         break;
     case XCB_GRAVITY_SOUTH_WEST: // bottom left corner doesn't move
         newy = newy + height() - h;
         break;
     case XCB_GRAVITY_SOUTH: // middle of bottom border doesn't move
         newx = (newx + width() / 2) - (w / 2);
         newy = newy + height() - h;
         break;
     case XCB_GRAVITY_SOUTH_EAST: // bottom right corner doesn't move
         newx = newx + width() - w;
         newy = newy + height() - h;
         break;
     }
     setFrameGeometry(QRect{newx, newy, w, h}, force);
 }
 
 // _NET_MOVERESIZE_WINDOW
 void X11Client::NETMoveResizeWindow(int flags, int x, int y, int width, int height)
 {
     int gravity = flags & 0xff;
     int value_mask = 0;
     if (flags & (1 << 8)) {
         value_mask |= XCB_CONFIG_WINDOW_X;
     }
     if (flags & (1 << 9)) {
         value_mask |= XCB_CONFIG_WINDOW_Y;
     }
     if (flags & (1 << 10)) {
         value_mask |= XCB_CONFIG_WINDOW_WIDTH;
     }
     if (flags & (1 << 11)) {
         value_mask |= XCB_CONFIG_WINDOW_HEIGHT;
     }
     configureRequest(value_mask, x, y, width, height, gravity, true);
 }
 
 bool X11Client::isMovable() const
 {
     if (!hasNETSupport() && !m_motif.move()) {
         return false;
     }
     if (isFullScreen())
         return false;
     if (isSpecialWindow() && !isSplash() && !isToolbar())  // allow moving of splashscreens :)
         return false;
     if (rules()->checkPosition(invalidPoint) != invalidPoint)     // forced position
         return false;
     return true;
 }
 
 bool X11Client::isMovableAcrossScreens() const
 {
     if (!hasNETSupport() && !m_motif.move()) {
         return false;
     }
     if (isSpecialWindow() && !isSplash() && !isToolbar())  // allow moving of splashscreens :)
         return false;
     if (rules()->checkPosition(invalidPoint) != invalidPoint)     // forced position
         return false;
     return true;
 }
 
 bool X11Client::isResizable() const
 {
     if (!hasNETSupport() && !m_motif.resize()) {
         return false;
     }
     if (isFullScreen())
         return false;
     if (isSpecialWindow() || isSplash() || isToolbar())
         return false;
     if (rules()->checkSize(QSize()).isValid())   // forced size
         return false;
     const Position mode = moveResizePointerMode();
     if ((mode == PositionTop || mode == PositionTopLeft || mode == PositionTopRight ||
          mode == PositionLeft || mode == PositionBottomLeft) && rules()->checkPosition(invalidPoint) != invalidPoint)
         return false;
 
     QSize min = minSize();
     QSize max = maxSize();
     return min.width() < max.width() || min.height() < max.height();
 }
 
 bool X11Client::isMaximizable() const
 {
     if (!isResizable() || isToolbar())  // SELI isToolbar() ?
         return false;
     if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore && rules()->checkMaximize(MaximizeFull) != MaximizeRestore)
         return true;
     return false;
 }
 
 
 /**
  * Reimplemented to inform the client about the new window position.
  */
 void X11Client::setFrameGeometry(const QRect &rect, ForceGeometry_t force)
 {
     // this code is also duplicated in X11Client::plainResize()
     // Ok, the shading geometry stuff. Generally, code doesn't care about shaded geometry,
     // simply because there are too many places dealing with geometry. Those places
     // ignore shaded state and use normal geometry, which they usually should get
     // from adjustedSize(). Such geometry comes here, and if the window is shaded,
     // the geometry is used only for client_size, since that one is not used when
     // shading. Then the frame geometry is adjusted for the shaded geometry.
     // This gets more complicated in the case the code does only something like
     // setGeometry( geometry()) - geometry() will return the shaded frame geometry.
     // Such code is wrong and should be changed to handle the case when the window is shaded,
     // for example using X11Client::clientSize()
 
     QRect frameGeometry = rect;
 
     if (shade_geometry_change)
         ; // nothing
     else if (isShade()) {
         if (frameGeometry.height() == borderTop() + borderBottom()) {
             qCDebug(KWIN_CORE) << "Shaded geometry passed for size:";
         } else {
             m_clientGeometry = frameRectToClientRect(frameGeometry);
             frameGeometry.setHeight(borderTop() + borderBottom());
         }
     } else {
         m_clientGeometry = frameRectToClientRect(frameGeometry);
     }
     const QRect bufferGeometry = frameRectToBufferRect(frameGeometry);
     if (!areGeometryUpdatesBlocked() && frameGeometry != rules()->checkGeometry(frameGeometry)) {
         qCDebug(KWIN_CORE) << "forced geometry fail:" << frameGeometry << ":" << rules()->checkGeometry(frameGeometry);
     }
     m_frameGeometry = frameGeometry;
     if (force == NormalGeometrySet && m_bufferGeometry == bufferGeometry && pendingGeometryUpdate() == PendingGeometryNone) {
         return;
     }
     m_bufferGeometry = bufferGeometry;
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     updateServerGeometry();
     updateWindowRules(Rules::Position|Rules::Size);
 
     // keep track of old maximize mode
     // to detect changes
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
 
     // Need to regenerate decoration pixmaps when the buffer size is changed.
     if (bufferGeometryBeforeUpdateBlocking().size() != m_bufferGeometry.size()) {
         discardWindowPixmap();
     }
     if (frameGeometryBeforeUpdateBlocking() != m_frameGeometry) {
         emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     }
     emit geometryShapeChanged(this, frameGeometryBeforeUpdateBlocking());
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 void X11Client::plainResize(int w, int h, ForceGeometry_t force)
 {
     QSize frameSize(w, h);
     QSize bufferSize;
 
     // this code is also duplicated in X11Client::setGeometry(), and it's also commented there
     if (shade_geometry_change)
         ; // nothing
     else if (isShade()) {
         if (frameSize.height() == borderTop() + borderBottom()) {
             qCDebug(KWIN_CORE) << "Shaded geometry passed for size:";
         } else {
             m_clientGeometry.setSize(frameSizeToClientSize(frameSize));
             frameSize.setHeight(borderTop() + borderBottom());
         }
     } else {
         m_clientGeometry.setSize(frameSizeToClientSize(frameSize));
     }
     if (isDecorated()) {
         bufferSize = frameSize;
     } else {
         bufferSize = m_clientGeometry.size();
     }
     if (!areGeometryUpdatesBlocked() && frameSize != rules()->checkSize(frameSize)) {
         qCDebug(KWIN_CORE) << "forced size fail:" << frameSize << ":" << rules()->checkSize(frameSize);
     }
     m_frameGeometry.setSize(frameSize);
     // resuming geometry updates is handled only in setGeometry()
     Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
     if (force == NormalGeometrySet && m_bufferGeometry.size() == bufferSize) {
         return;
     }
     m_bufferGeometry.setSize(bufferSize);
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     updateServerGeometry();
     updateWindowRules(Rules::Position|Rules::Size);
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
     if (bufferGeometryBeforeUpdateBlocking().size() != m_bufferGeometry.size()) {
         discardWindowPixmap();
     }
     if (frameGeometryBeforeUpdateBlocking() != frameGeometry()) {
         emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     }
     emit geometryShapeChanged(this, frameGeometryBeforeUpdateBlocking());
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 void X11Client::updateServerGeometry()
 {
     const QRect oldBufferGeometry = bufferGeometryBeforeUpdateBlocking();
 
     if (oldBufferGeometry.size() != m_bufferGeometry.size() || pendingGeometryUpdate() == PendingGeometryForced) {
         resizeDecoration();
         // If the client is being interactively resized, then the frame window, the wrapper window,
         // and the client window have correct geometry at this point, so we don't have to configure
         // them again. If the client doesn't support frame counters, always update geometry.
         const bool needsGeometryUpdate = !isResize() || m_syncRequest.counter == XCB_NONE;
         if (needsGeometryUpdate) {
             m_frame.setGeometry(m_bufferGeometry);
         }
         if (!isShade()) {
             if (needsGeometryUpdate) {
                 m_wrapper.setGeometry(QRect(clientPos(), clientSize()));
                 m_client.setGeometry(QRect(QPoint(0, 0), clientSize()));
             }
             // SELI - won't this be too expensive?
             // THOMAS - yes, but gtk+ clients will not resize without ...
             sendSyntheticConfigureNotify();
         }
         updateShape();
     } else {
         if (isMoveResize()) {
             if (compositing()) { // Defer the X update until we leave this mode
                 needsXWindowMove = true;
             } else {
                 m_frame.move(m_bufferGeometry.topLeft()); // sendSyntheticConfigureNotify() on finish shall be sufficient
             }
         } else {
             m_frame.move(m_bufferGeometry.topLeft());
             sendSyntheticConfigureNotify();
         }
         // Unconditionally move the input window: it won't affect rendering
         m_decoInputExtent.move(pos() + inputPos());
     }
 }
 
 static bool changeMaximizeRecursion = false;
 void X11Client::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     if (changeMaximizeRecursion)
         return;
 
     if (!isResizable() || isToolbar())  // SELI isToolbar() ?
         return;
 
     QRect clientArea;
     if (isElectricBorderMaximizing())
         clientArea = workspace()->clientArea(MaximizeArea, Cursors::self()->mouse()->pos(), desktop());
     else
         clientArea = workspace()->clientArea(MaximizeArea, this);
 
     MaximizeMode old_mode = max_mode;
     // 'adjust == true' means to update the size only, e.g. after changing workspace size
     if (!adjust) {
         if (vertical)
             max_mode = MaximizeMode(max_mode ^ MaximizeVertical);
         if (horizontal)
             max_mode = MaximizeMode(max_mode ^ MaximizeHorizontal);
     }
 
     // if the client insist on a fix aspect ratio, we check whether the maximizing will get us
     // out of screen bounds and take that as a "full maximization with aspect check" then
     if (m_geometryHints.hasAspect() && // fixed aspect
         (max_mode == MaximizeVertical || max_mode == MaximizeHorizontal) && // ondimensional maximization
         rules()->checkStrictGeometry(true)) { // obey aspect
         const QSize minAspect = m_geometryHints.minAspect();
         const QSize maxAspect = m_geometryHints.maxAspect();
         if (max_mode == MaximizeVertical || (old_mode & MaximizeVertical)) {
             const double fx = minAspect.width(); // use doubles, because the values can be MAX_INT
             const double fy = maxAspect.height(); // use doubles, because the values can be MAX_INT
             if (fx*clientArea.height()/fy > clientArea.width()) // too big
                 max_mode = old_mode & MaximizeHorizontal ? MaximizeRestore : MaximizeFull;
         } else { // max_mode == MaximizeHorizontal
             const double fx = maxAspect.width();
             const double fy = minAspect.height();
             if (fy*clientArea.width()/fx > clientArea.height()) // too big
                 max_mode = old_mode & MaximizeVertical ? MaximizeRestore : MaximizeFull;
         }
     }
 
     max_mode = rules()->checkMaximize(max_mode);
     if (!adjust && max_mode == old_mode)
         return;
 
     GeometryUpdatesBlocker blocker(this);
 
     // maximing one way and unmaximizing the other way shouldn't happen,
     // so restore first and then maximize the other way
     if ((old_mode == MaximizeVertical && max_mode == MaximizeHorizontal)
             || (old_mode == MaximizeHorizontal && max_mode == MaximizeVertical)) {
         changeMaximize(false, false, false);   // restore
     }
 
     // save sizes for restoring, if maximalizing
     QSize sz;
     if (isShade())
         sz = adjustedSize();
     else
         sz = size();
 
     if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
         QRect savedGeometry = geometryRestore();
         if (!adjust && !(old_mode & MaximizeVertical)) {
             savedGeometry.setTop(y());
             savedGeometry.setHeight(sz.height());
         }
         if (!adjust && !(old_mode & MaximizeHorizontal)) {
             savedGeometry.setLeft(x());
             savedGeometry.setWidth(sz.width());
         }
         setGeometryRestore(savedGeometry);
     }
 
     // call into decoration update borders
     if (isDecorated() && decoration()->client() && !(options->borderlessMaximizedWindows() && max_mode == KWin::MaximizeFull)) {
         changeMaximizeRecursion = true;
         const auto c = decoration()->client().data();
         if ((max_mode & MaximizeVertical) != (old_mode & MaximizeVertical)) {
             emit c->maximizedVerticallyChanged(max_mode & MaximizeVertical);
         }
         if ((max_mode & MaximizeHorizontal) != (old_mode & MaximizeHorizontal)) {
             emit c->maximizedHorizontallyChanged(max_mode & MaximizeHorizontal);
         }
         if ((max_mode == MaximizeFull) != (old_mode == MaximizeFull)) {
             emit c->maximizedChanged(max_mode & MaximizeFull);
         }
         changeMaximizeRecursion = false;
     }
 
     if (options->borderlessMaximizedWindows()) {
         // triggers a maximize change.
         // The next setNoBorder interation will exit since there's no change but the first recursion pullutes the restore geometry
         changeMaximizeRecursion = true;
         setNoBorder(rules()->checkNoBorder(app_noborder || (m_motif.hasDecoration() && m_motif.noBorder()) || max_mode == MaximizeFull));
         changeMaximizeRecursion = false;
     }
 
     const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
 
     // Conditional quick tiling exit points
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         if (old_mode == MaximizeFull &&
                 !clientArea.contains(geometryRestore().center())) {
             // Not restoring on the same screen
             // TODO: The following doesn't work for some reason
             //quick_tile_mode = QuickTileFlag::None; // And exit quick tile mode manually
         } else if ((old_mode == MaximizeVertical && max_mode == MaximizeRestore) ||
                   (old_mode == MaximizeFull && max_mode == MaximizeHorizontal)) {
             // Modifying geometry of a tiled window
             updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry
         }
     }
 
     switch(max_mode) {
 
     case MaximizeVertical: {
         if (old_mode & MaximizeHorizontal) { // actually restoring from MaximizeFull
             if (geometryRestore().width() == 0 || !clientArea.contains(geometryRestore().center())) {
                 // needs placement
                 plainResize(constrainFrameSize(QSize(width() * 2 / 3, clientArea.height()), SizeModeFixedH), geom_mode);
                 Placement::self()->placeSmart(this, clientArea);
             } else {
                 setFrameGeometry(QRect(QPoint(geometryRestore().x(), clientArea.top()),
                                        constrainFrameSize(QSize(geometryRestore().width(), clientArea.height()), SizeModeFixedH)), geom_mode);
             }
         } else {
             QRect r(x(), clientArea.top(), width(), clientArea.height());
             r.setTopLeft(rules()->checkPosition(r.topLeft()));
             r.setSize(constrainFrameSize(r.size(), SizeModeFixedH));
             setFrameGeometry(r, geom_mode);
         }
         info->setState(NET::MaxVert, NET::Max);
         break;
     }
 
     case MaximizeHorizontal: {
         if (old_mode & MaximizeVertical) { // actually restoring from MaximizeFull
             if (geometryRestore().height() == 0 || !clientArea.contains(geometryRestore().center())) {
                 // needs placement
                 plainResize(constrainFrameSize(QSize(clientArea.width(), height() * 2 / 3), SizeModeFixedW), geom_mode);
                 Placement::self()->placeSmart(this, clientArea);
             } else {
                 setFrameGeometry(QRect(QPoint(clientArea.left(), geometryRestore().y()),
                                        constrainFrameSize(QSize(clientArea.width(), geometryRestore().height()), SizeModeFixedW)), geom_mode);
             }
         } else {
             QRect r(clientArea.left(), y(), clientArea.width(), height());
             r.setTopLeft(rules()->checkPosition(r.topLeft()));
             r.setSize(constrainFrameSize(r.size(), SizeModeFixedW));
             setFrameGeometry(r, geom_mode);
         }
         info->setState(NET::MaxHoriz, NET::Max);
         break;
     }
 
     case MaximizeRestore: {
         QRect restore = frameGeometry();
         // when only partially maximized, geom_restore may not have the other dimension remembered
         if (old_mode & MaximizeVertical) {
             restore.setTop(geometryRestore().top());
             restore.setBottom(geometryRestore().bottom());
         }
         if (old_mode & MaximizeHorizontal) {
             restore.setLeft(geometryRestore().left());
             restore.setRight(geometryRestore().right());
         }
         if (!restore.isValid()) {
             QSize s = QSize(clientArea.width() * 2 / 3, clientArea.height() * 2 / 3);
             if (geometryRestore().width() > 0) {
                 s.setWidth(geometryRestore().width());
             }
             if (geometryRestore().height() > 0) {
                 s.setHeight(geometryRestore().height());
             }
             plainResize(constrainFrameSize(s));
             Placement::self()->placeSmart(this, clientArea);
             restore = frameGeometry();
             if (geometryRestore().width() > 0) {
                 restore.moveLeft(geometryRestore().x());
             }
             if (geometryRestore().height() > 0) {
                 restore.moveTop(geometryRestore().y());
             }
             setGeometryRestore(restore); // relevant for mouse pos calculation, bug #298646
         }
         if (m_geometryHints.hasAspect()) {
             restore.setSize(constrainFrameSize(restore.size(), SizeModeAny));
         }
         setFrameGeometry(restore, geom_mode);
         if (!clientArea.contains(geometryRestore().center())) { // Not restoring to the same screen
             Placement::self()->place(this, clientArea);
         }
         info->setState(NET::States(), NET::Max);
         updateQuickTileMode(QuickTileFlag::None);
         break;
     }
 
     case MaximizeFull: {
         QRect r(clientArea);
         r.setTopLeft(rules()->checkPosition(r.topLeft()));
         r.setSize(constrainFrameSize(r.size(), SizeModeMax));
         if (r.size() != clientArea.size()) { // to avoid off-by-one errors...
             if (isElectricBorderMaximizing() && r.width() < clientArea.width()) {
                 r.moveLeft(qMax(clientArea.left(), Cursors::self()->mouse()->pos().x() - r.width()/2));
                 r.moveRight(qMin(clientArea.right(), r.right()));
             } else {
                 r.moveCenter(clientArea.center());
                 const bool closeHeight = r.height() > 97*clientArea.height()/100;
                 const bool closeWidth  = r.width()  > 97*clientArea.width() /100;
                 const bool overHeight = r.height() > clientArea.height();
                 const bool overWidth  = r.width()  > clientArea.width();
                 if (closeWidth || closeHeight) {
                     Position titlePos = titlebarPosition();
                     const QRect screenArea = workspace()->clientArea(ScreenArea, clientArea.center(), desktop());
                     if (closeHeight) {
                         bool tryBottom = titlePos == PositionBottom;
                         if ((overHeight && titlePos == PositionTop) ||
                             screenArea.top() == clientArea.top())
                             r.setTop(clientArea.top());
                         else
                             tryBottom = true;
                         if (tryBottom &&
                             (overHeight || screenArea.bottom() == clientArea.bottom()))
                             r.setBottom(clientArea.bottom());
                     }
                     if (closeWidth) {
                         bool tryLeft = titlePos == PositionLeft;
                         if ((overWidth && titlePos == PositionRight) ||
                             screenArea.right() == clientArea.right())
                             r.setRight(clientArea.right());
                         else
                             tryLeft = true;
                         if (tryLeft && (overWidth || screenArea.left() == clientArea.left()))
                             r.setLeft(clientArea.left());
                     }
                 }
             }
             r.moveTopLeft(rules()->checkPosition(r.topLeft()));
         }
         setFrameGeometry(r, geom_mode);
         if (options->electricBorderMaximize() && r.top() == clientArea.top())
             updateQuickTileMode(QuickTileFlag::Maximize);
         else
             updateQuickTileMode(QuickTileFlag::None);
         info->setState(NET::Max, NET::Max);
         break;
     }
     default:
         break;
     }
 
     updateAllowedActions();
     updateWindowRules(Rules::MaximizeVert|Rules::MaximizeHoriz|Rules::Position|Rules::Size);
     emit quickTileModeChanged();
 }
 
 bool X11Client::userCanSetFullScreen() const
 {
     if (!isFullScreenable()) {
         return false;
     }
     return isNormalWindow() || isDialog();
 }
 
 void X11Client::setFullScreen(bool set, bool user)
 {
     set = rules()->checkFullScreen(set);
 
     const bool wasFullscreen = isFullScreen();
     if (wasFullscreen == set) {
         return;
     }
     if (user && !userCanSetFullScreen()) {
         return;
     }
 
     setShade(ShadeNone);
 
     if (wasFullscreen) {
         workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
     } else {
         geom_fs_restore = frameGeometry();
     }
 
     if (set) {
         m_fullscreenMode = FullScreenNormal;
         workspace()->raiseClient(this);
     } else {
         m_fullscreenMode = FullScreenNone;
     }
 
     StackingUpdatesBlocker blocker1(workspace());
     GeometryUpdatesBlocker blocker2(this);
 
     // active fullscreens get different layer
     workspace()->updateClientLayer(this);
 
     info->setState(isFullScreen() ? NET::FullScreen : NET::States(), NET::FullScreen);
     updateDecoration(false, false);
 
     if (set) {
         if (info->fullscreenMonitors().isSet()) {
             setFrameGeometry(fullscreenMonitorsArea(info->fullscreenMonitors()));
         } else {
             setFrameGeometry(workspace()->clientArea(FullScreenArea, this));
         }
     } else {
         Q_ASSERT(!geom_fs_restore.isNull());
         const int currentScreen = screen();
         setFrameGeometry(QRect(geom_fs_restore.topLeft(), constrainFrameSize(geom_fs_restore.size())));
         if(currentScreen != screen()) {
             workspace()->sendClientToScreen(this, currentScreen);
         }
     }
 
     updateWindowRules(Rules::Fullscreen | Rules::Position | Rules::Size);
     emit clientFullScreenSet(this, set, user);
     emit fullScreenChanged();
 }
 
 
 void X11Client::updateFullscreenMonitors(NETFullscreenMonitors topology)
 {
     int nscreens = screens()->count();
 
 //    qDebug() << "incoming request with top: " << topology.top << " bottom: " << topology.bottom
 //                   << " left: " << topology.left << " right: " << topology.right
 //                   << ", we have: " << nscreens << " screens.";
 
     if (topology.top >= nscreens ||
             topology.bottom >= nscreens ||
             topology.left >= nscreens ||
             topology.right >= nscreens) {
         qCWarning(KWIN_CORE) << "fullscreenMonitors update failed. request higher than number of screens.";
         return;
     }
 
     info->setFullscreenMonitors(topology);
     if (isFullScreen())
         setFrameGeometry(fullscreenMonitorsArea(topology));
 }
 
 /**
  * Calculates the bounding rectangle defined by the 4 monitor indices indicating the
  * top, bottom, left, and right edges of the window when the fullscreen state is enabled.
  */
 QRect X11Client::fullscreenMonitorsArea(NETFullscreenMonitors requestedTopology) const
 {
     QRect top, bottom, left, right, total;
 
     top = screens()->geometry(requestedTopology.top);
     bottom = screens()->geometry(requestedTopology.bottom);
     left = screens()->geometry(requestedTopology.left);
     right = screens()->geometry(requestedTopology.right);
     total = top.united(bottom.united(left.united(right)));
 
 //    qDebug() << "top: " << top << " bottom: " << bottom
 //                   << " left: " << left << " right: " << right;
 //    qDebug() << "returning rect: " << total;
     return total;
 }
 
 static GeometryTip* geometryTip    = nullptr;
 
 void X11Client::positionGeometryTip()
 {
     Q_ASSERT(isMove() || isResize());
     // Position and Size display
     if (effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::GeometryTip))
         return; // some effect paints this for us
     if (options->showGeometryTip()) {
         if (!geometryTip) {
             geometryTip = new GeometryTip(&m_geometryHints);
         }
         QRect wgeom(moveResizeGeometry());   // position of the frame, size of the window itself
         wgeom.setWidth(wgeom.width() - (width() - clientSize().width()));
         wgeom.setHeight(wgeom.height() - (height() - clientSize().height()));
         if (isShade())
             wgeom.setHeight(0);
         geometryTip->setGeometry(wgeom);
         if (!geometryTip->isVisible())
             geometryTip->show();
         geometryTip->raise();
     }
 }
 
 bool X11Client::doStartMoveResize()
 {
     bool has_grab = false;
     // This reportedly improves smoothness of the moveresize operation,
     // something with Enter/LeaveNotify events, looks like XFree performance problem or something *shrug*
     // (https://lists.kde.org/?t=107302193400001&r=1&w=2)
     QRect r = workspace()->clientArea(FullArea, this);
     m_moveResizeGrabWindow.create(r, XCB_WINDOW_CLASS_INPUT_ONLY, 0, nullptr, rootWindow());
     m_moveResizeGrabWindow.map();
     m_moveResizeGrabWindow.raise();
     updateXTime();
     const xcb_grab_pointer_cookie_t cookie = xcb_grab_pointer_unchecked(connection(), false, m_moveResizeGrabWindow,
         XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION |
         XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
         XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, m_moveResizeGrabWindow, Cursors::self()->mouse()->x11Cursor(cursor()), xTime());
     ScopedCPointer<xcb_grab_pointer_reply_t> pointerGrab(xcb_grab_pointer_reply(connection(), cookie, nullptr));
     if (!pointerGrab.isNull() && pointerGrab->status == XCB_GRAB_STATUS_SUCCESS) {
         has_grab = true;
     }
     if (!has_grab && grabXKeyboard(frameId()))
         has_grab = move_resize_has_keyboard_grab = true;
     if (!has_grab) { // at least one grab is necessary in order to be able to finish move/resize
         m_moveResizeGrabWindow.reset();
         return false;
     }
     return true;
 }
 
 void X11Client::leaveMoveResize()
 {
     if (needsXWindowMove) {
         // Do the deferred move
         m_frame.move(m_bufferGeometry.topLeft());
         needsXWindowMove = false;
     }
     if (!isResize())
         sendSyntheticConfigureNotify(); // tell the client about it's new final position
     if (geometryTip) {
         geometryTip->hide();
         delete geometryTip;
         geometryTip = nullptr;
     }
     if (move_resize_has_keyboard_grab)
         ungrabXKeyboard();
     move_resize_has_keyboard_grab = false;
     xcb_ungrab_pointer(connection(), xTime());
     m_moveResizeGrabWindow.reset();
     if (m_syncRequest.counter == XCB_NONE) { // don't forget to sanitize since the timeout will no more fire
         m_syncRequest.isPending = false;
     }
     delete m_syncRequest.timeout;
     m_syncRequest.timeout = nullptr;
     AbstractClient::leaveMoveResize();
 }
 
 bool X11Client::isWaitingForMoveResizeSync() const
 {
     return m_syncRequest.isPending && isResize();
 }
 
 void X11Client::doResizeSync()
 {
     if (!m_syncRequest.timeout) {
         m_syncRequest.timeout = new QTimer(this);
         connect(m_syncRequest.timeout, &QTimer::timeout, this, &X11Client::performMoveResize);
         m_syncRequest.timeout->setSingleShot(true);
     }
     if (m_syncRequest.counter != XCB_NONE) {
         m_syncRequest.timeout->start(250);
         sendSyncRequest();
     } else {                              // for clients not supporting the XSYNC protocol, we
         m_syncRequest.isPending = true;   // limit the resizes to 30Hz to take pointless load from X11
         m_syncRequest.timeout->start(33); // and the client, the mouse is still moved at full speed
     }                                     // and no human can control faster resizes anyway
     const QRect moveResizeClientGeometry = frameRectToClientRect(moveResizeGeometry());
     const QRect moveResizeBufferGeometry = frameRectToBufferRect(moveResizeGeometry());
 
     // According to the Composite extension spec, a window will get a new pixmap allocated each time
     // it is mapped or resized. Given that we redirect frame windows and not client windows, we have
     // to resize the frame window in order to forcefully reallocate offscreen storage. If we don't do
     // this, then we might render partially updated client window. I know, it sucks.
     m_frame.setGeometry(moveResizeBufferGeometry);
     m_wrapper.setGeometry(QRect(clientPos(), moveResizeClientGeometry.size()));
     m_client.setGeometry(QRect(QPoint(0, 0), moveResizeClientGeometry.size()));
 }
 
 void X11Client::doPerformMoveResize()
 {
     if (m_syncRequest.counter == XCB_NONE) { // client w/o XSYNC support. allow the next resize event
         m_syncRequest.isPending = false;     // NEVER do this for clients with a valid counter
     }                                        // (leads to sync request races in some clients)
 }
 
 /**
  * Returns \a area with the client's strut taken into account.
  *
  * Used from Workspace in updateClientArea.
  */
 // TODO move to Workspace?
 
 QRect X11Client::adjustedClientArea(const QRect &desktopArea, const QRect& area) const
 {
     QRect r = area;
     NETExtendedStrut str = strut();
     QRect stareaL = QRect(
                         0,
                         str . left_start,
                         str . left_width,
                         str . left_end - str . left_start + 1);
     QRect stareaR = QRect(
                         desktopArea . right() - str . right_width + 1,
                         str . right_start,
                         str . right_width,
                         str . right_end - str . right_start + 1);
     QRect stareaT = QRect(
                         str . top_start,
                         0,
                         str . top_end - str . top_start + 1,
                         str . top_width);
     QRect stareaB = QRect(
                         str . bottom_start,
                         desktopArea . bottom() - str . bottom_width + 1,
                         str . bottom_end - str . bottom_start + 1,
                         str . bottom_width);
 
     QRect screenarea = workspace()->clientArea(ScreenArea, this);
     // HACK: workarea handling is not xinerama aware, so if this strut
     // reserves place at a xinerama edge that's inside the virtual screen,
     // ignore the strut for workspace setting.
     if (area == QRect(QPoint(0, 0), screens()->displaySize())) {
         if (stareaL.left() < screenarea.left())
             stareaL = QRect();
         if (stareaR.right() > screenarea.right())
             stareaR = QRect();
         if (stareaT.top() < screenarea.top())
             stareaT = QRect();
         if (stareaB.bottom() < screenarea.bottom())
             stareaB = QRect();
     }
     // Handle struts at xinerama edges that are inside the virtual screen.
     // They're given in virtual screen coordinates, make them affect only
     // their xinerama screen.
     stareaL.setLeft(qMax(stareaL.left(), screenarea.left()));
     stareaR.setRight(qMin(stareaR.right(), screenarea.right()));
     stareaT.setTop(qMax(stareaT.top(), screenarea.top()));
     stareaB.setBottom(qMin(stareaB.bottom(), screenarea.bottom()));
 
     if (stareaL . intersects(area)) {
 //        qDebug() << "Moving left of: " << r << " to " << stareaL.right() + 1;
         r . setLeft(stareaL . right() + 1);
     }
     if (stareaR . intersects(area)) {
 //        qDebug() << "Moving right of: " << r << " to " << stareaR.left() - 1;
         r . setRight(stareaR . left() - 1);
     }
     if (stareaT . intersects(area)) {
 //        qDebug() << "Moving top of: " << r << " to " << stareaT.bottom() + 1;
         r . setTop(stareaT . bottom() + 1);
     }
     if (stareaB . intersects(area)) {
 //        qDebug() << "Moving bottom of: " << r << " to " << stareaB.top() - 1;
         r . setBottom(stareaB . top() - 1);
     }
 
     return r;
 }
 
 NETExtendedStrut X11Client::strut() const
 {
     NETExtendedStrut ext = info->extendedStrut();
     NETStrut str = info->strut();
     const QSize displaySize = screens()->displaySize();
     if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
             && (str.left != 0 || str.right != 0 || str.top != 0 || str.bottom != 0)) {
         // build extended from simple
         if (str.left != 0) {
             ext.left_width = str.left;
             ext.left_start = 0;
             ext.left_end = displaySize.height();
         }
         if (str.right != 0) {
             ext.right_width = str.right;
             ext.right_start = 0;
             ext.right_end = displaySize.height();
         }
         if (str.top != 0) {
             ext.top_width = str.top;
             ext.top_start = 0;
             ext.top_end = displaySize.width();
         }
         if (str.bottom != 0) {
             ext.bottom_width = str.bottom;
             ext.bottom_start = 0;
             ext.bottom_end = displaySize.width();
         }
     }
     return ext;
 }
 
 StrutRect X11Client::strutRect(StrutArea area) const
 {
     Q_ASSERT(area != StrutAreaAll);   // Not valid
     const QSize displaySize = screens()->displaySize();
     NETExtendedStrut strutArea = strut();
     switch(area) {
     case StrutAreaTop:
         if (strutArea.top_width != 0)
             return StrutRect(QRect(
                                  strutArea.top_start, 0,
                                  strutArea.top_end - strutArea.top_start, strutArea.top_width
                              ), StrutAreaTop);
         break;
     case StrutAreaRight:
         if (strutArea.right_width != 0)
             return StrutRect(QRect(
                                  displaySize.width() - strutArea.right_width, strutArea.right_start,
                                  strutArea.right_width, strutArea.right_end - strutArea.right_start
                              ), StrutAreaRight);
         break;
     case StrutAreaBottom:
         if (strutArea.bottom_width != 0)
             return StrutRect(QRect(
                                  strutArea.bottom_start, displaySize.height() - strutArea.bottom_width,
                                  strutArea.bottom_end - strutArea.bottom_start, strutArea.bottom_width
                              ), StrutAreaBottom);
         break;
     case StrutAreaLeft:
         if (strutArea.left_width != 0)
             return StrutRect(QRect(
                                  0, strutArea.left_start,
                                  strutArea.left_width, strutArea.left_end - strutArea.left_start
                              ), StrutAreaLeft);
         break;
     default:
         abort(); // Not valid
     }
     return StrutRect(); // Null rect
 }
 
 StrutRects X11Client::strutRects() const
 {
     StrutRects region;
     region += strutRect(StrutAreaTop);
     region += strutRect(StrutAreaRight);
     region += strutRect(StrutAreaBottom);
     region += strutRect(StrutAreaLeft);
     return region;
 }
 
 bool X11Client::hasStrut() const
 {
     NETExtendedStrut ext = strut();
     if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0)
         return false;
     return true;
 }
 
 bool X11Client::hasOffscreenXineramaStrut() const
 {
     // Get strut as a QRegion
     QRegion region;
     region += strutRect(StrutAreaTop);
     region += strutRect(StrutAreaRight);
     region += strutRect(StrutAreaBottom);
     region += strutRect(StrutAreaLeft);
 
     // Remove all visible areas so that only the invisible remain
     for (int i = 0; i < screens()->count(); i ++)
         region -= screens()->geometry(i);
 
     // If there's anything left then we have an offscreen strut
     return !region.isEmpty();
 }
 
 void X11Client::applyWindowRules()
 {
     AbstractClient::applyWindowRules();
     setBlockingCompositing(info->isBlockingCompositing());
 }
 
 void X11Client::damageNotifyEvent()
 {
     if (m_syncRequest.isPending && isResize()) {
         emit damaged(this, QRect());
         m_isDamaged = true;
         return;
     }
 
     if (!readyForPainting()) { // avoid "setReadyForPainting()" function calling overhead
         if (m_syncRequest.counter == XCB_NONE) {  // cannot detect complete redraw, consider done now
             setReadyForPainting();
             setupWindowManagementInterface();
         }
     }
 
     AbstractClient::damageNotifyEvent();
 }
 
 void X11Client::updateWindowPixmap()
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         effectWindow()->sceneWindow()->updatePixmap();
     }
 }
 
 } // namespace
diff --git a/x11client.h b/x11client.h
index a4a41b037..268f6aaaa 100644
--- a/x11client.h
+++ b/x11client.h
@@ -1,689 +1,672 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #pragma once
 
 // kwin
 #include "options.h"
 #include "rules.h"
 #include "abstract_client.h"
 #include "xcbutils.h"
 // Qt
 #include <QElapsedTimer>
 #include <QFlags>
 #include <QPointer>
 #include <QPixmap>
 #include <QWindow>
 // X
 #include <xcb/sync.h>
 
 // TODO: Cleanup the order of things in this .h file
 
 class QTimer;
 class KStartupInfoData;
 class KStartupInfoId;
 
 namespace KWin
 {
 
 
 /**
  * @brief Defines Predicates on how to search for a Client.
  *
  * Used by Workspace::findClient.
  */
 enum class Predicate {
     WindowMatch,
     WrapperIdMatch,
     FrameIdMatch,
     InputIdMatch
 };
 
 class KWIN_EXPORT X11Client : public AbstractClient
 {
     Q_OBJECT
     /**
      * By how much the window wishes to grow/shrink at least. Usually QSize(1,1).
      * MAY BE DISOBEYED BY THE WM! It's only for information, do NOT rely on it at all.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(QSize basicUnit READ basicUnit)
     /**
      * A client can block compositing. That is while the Client is alive and the state is set,
      * Compositing is suspended and is resumed when there are no Clients blocking compositing any
      * more.
      *
      * This is actually set by a window property, unfortunately not used by the target application
      * group. For convenience it's exported as a property to the scripts.
      *
      * Use with care!
      */
     Q_PROPERTY(bool blocksCompositing READ isBlockingCompositing WRITE setBlockingCompositing NOTIFY blockingCompositingChanged)
     /**
      * Whether the Client uses client side window decorations.
      * Only GTK+ are detected.
      */
     Q_PROPERTY(bool clientSideDecorated READ isClientSideDecorated NOTIFY clientSideDecoratedChanged)
 public:
     explicit X11Client();
     ~X11Client() override; ///< Use destroyClient() or releaseWindow()
 
     xcb_window_t wrapperId() const;
     xcb_window_t inputId() const { return m_decoInputExtent; }
     xcb_window_t frameId() const override;
 
     QRect inputGeometry() const override;
     QRect bufferGeometry() const override;
     QMargins bufferMargins() const override;
 
     QPoint framePosToClientPos(const QPoint &point) const override;
     QPoint clientPosToFramePos(const QPoint &point) const override;
     QSize frameSizeToClientSize(const QSize &size) const override;
     QSize clientSizeToFrameSize(const QSize &size) const override;
     QRect frameRectToBufferRect(const QRect &rect) const;
 
     QMatrix4x4 inputTransformation() const override;
 
     bool isTransient() const override;
     bool groupTransient() const override;
     bool wasOriginallyGroupTransient() const;
     QList<AbstractClient*> mainClients() const override; // Call once before loop , is not indirect
     bool hasTransient(const AbstractClient* c, bool indirect) const override;
     void checkTransient(xcb_window_t w);
     AbstractClient* findModal(bool allow_itself = false) override;
     const Group* group() const override;
     Group* group() override;
     void checkGroup(Group* gr = nullptr, bool force = false);
     void changeClientLeaderGroup(Group* gr);
     void updateWindowRules(Rules::Types selection) override;
     void applyWindowRules() override;
     void updateFullscreenMonitors(NETFullscreenMonitors topology);
 
     bool hasNETSupport() const;
 
     QSize minSize() const override;
     QSize maxSize() const override;
     QSize basicUnit() const;
     QSize clientSize() const override;
     QPoint inputPos() const { return input_offset; } // Inside of geometry()
 
     bool windowEvent(xcb_generic_event_t *e);
     NET::WindowType windowType(bool direct = false, int supported_types = 0) const override;
 
     bool manage(xcb_window_t w, bool isMapped);
     void releaseWindow(bool on_shutdown = false);
     void destroyClient() override;
 
     QStringList activities() const override;
     void setOnActivity(const QString &activity, bool enable);
     void setOnAllActivities(bool set) override;
     void setOnActivities(QStringList newActivitiesList) override;
     void updateActivities(bool includeTransients);
     void blockActivityUpdates(bool b = true) override;
 
     /// Is not minimized and not hidden. I.e. normally visible on some virtual desktop.
     bool isShown(bool shaded_is_shown) const override;
     bool isHiddenInternal() const override; // For compositing
 
-    ShadeMode shadeMode() const override; // Prefer isShade()
-    void setShade(ShadeMode mode) override;
     bool isShadeable() const override;
-
     bool isMaximizable() const override;
     MaximizeMode maximizeMode() const override;
 
     bool isMinimizable() const override;
     QRect iconGeometry() const override;
 
     bool isFullScreenable() const override;
     void setFullScreen(bool set, bool user = true) override;
     bool isFullScreen() const override;
     bool userCanSetFullScreen() const override;
     QRect geometryFSRestore() const {
         return geom_fs_restore;     // only for session saving
     }
     int fullScreenMode() const {
         return m_fullscreenMode;    // only for session saving
     }
 
     bool userNoBorder() const;
     bool noBorder() const override;
     void setNoBorder(bool set) override;
     bool userCanSetNoBorder() const override;
     void checkNoBorder() override;
 
     int sessionStackingOrder() const;
 
     // Auxiliary functions, depend on the windowType
     bool wantsInput() const override;
 
     bool isResizable() const override;
     bool isMovable() const override;
     bool isMovableAcrossScreens() const override;
     bool isCloseable() const override; ///< May be closed by the user (May have a close button)
 
     void takeFocus() override;
 
     void updateDecoration(bool check_workspace_pos, bool force = false) override;
 
     void updateShape();
 
     using AbstractClient::move;
     void move(int x, int y, ForceGeometry_t force = NormalGeometrySet) override;
     void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet) override;
     /// plainResize() simply resizes
     void plainResize(int w, int h, ForceGeometry_t force = NormalGeometrySet);
     void plainResize(const QSize& s, ForceGeometry_t force = NormalGeometrySet);
     /// resizeWithChecks() resizes according to gravity, and checks workarea position
     void resizeWithChecks(const QSize &size, ForceGeometry_t force = NormalGeometrySet) override;
     void resizeWithChecks(int w, int h, xcb_gravity_t gravity, ForceGeometry_t force = NormalGeometrySet);
     void resizeWithChecks(const QSize& s, xcb_gravity_t gravity, ForceGeometry_t force = NormalGeometrySet);
     QSize constrainClientSize(const QSize &size, SizeMode mode = SizeModeAny) const override;
 
     bool providesContextHelp() const override;
 
-    bool performMouseCommand(Options::MouseCommand, const QPoint& globalPos) override;
-
     QRect adjustedClientArea(const QRect& desktop, const QRect& area) const;
 
     xcb_colormap_t colormap() const;
 
     /// Updates visibility depending on being shaded, virtual desktop, etc.
     void updateVisibility();
     /// Hides a client - Basically like minimize, but without effects, it's simply hidden
     void hideClient(bool hide) override;
     bool hiddenPreview() const; ///< Window is mapped in order to get a window pixmap
 
     bool setupCompositing() override;
     void finishCompositing(ReleaseReason releaseReason = ReleaseReason::Release) override;
     void setBlockingCompositing(bool block);
     inline bool isBlockingCompositing() { return blocks_compositing; }
 
     QString captionNormal() const override {
         return cap_normal;
     }
     QString captionSuffix() const override {
         return cap_suffix;
     }
 
     using AbstractClient::keyPressEvent;
     void keyPressEvent(uint key_code, xcb_timestamp_t time);   // FRAME ??
     void updateMouseGrab() override;
     xcb_window_t moveResizeGrabWindow() const;
 
     QPoint gravityAdjustment(xcb_gravity_t gravity) const;
     const QPoint calculateGravitation(bool invert) const;
 
     void NETMoveResize(int x_root, int y_root, NET::Direction direction);
     void NETMoveResizeWindow(int flags, int x, int y, int width, int height);
     void restackWindow(xcb_window_t above, int detail, NET::RequestSource source, xcb_timestamp_t timestamp,
                        bool send_event = false);
 
     void gotPing(xcb_timestamp_t timestamp);
 
     void updateUserTime(xcb_timestamp_t time = XCB_TIME_CURRENT_TIME);
     xcb_timestamp_t userTime() const override;
     bool hasUserTimeSupport() const;
 
     /// Does 'delete c;'
     static void deleteClient(X11Client *c);
 
     static bool belongToSameApplication(const X11Client *c1, const X11Client *c2, SameApplicationChecks checks = SameApplicationChecks());
     static bool sameAppWindowRoleMatch(const X11Client *c1, const X11Client *c2, bool active_hack);
 
     void killWindow() override;
-    void toggleShade();
     void showContextHelp() override;
-    void cancelShadeHoverTimer();
     void checkActiveModal();
     StrutRect strutRect(StrutArea area) const;
     StrutRects strutRects() const;
     bool hasStrut() const override;
 
     /**
      * If shown is true the client is mapped and raised, if false
      * the client is unmapped and hidden, this function is called
      * when the tabbing group of the client switches its visible
      * client.
      */
     void setClientShown(bool shown) override;
 
     /**
      * Whether or not the window has a strut that expands through the invisible area of
      * an xinerama setup where the monitors are not the same resolution.
      */
     bool hasOffscreenXineramaStrut() const;
 
     QRect transparentRect() const override;
 
     bool isClientSideDecorated() const;
     bool wantsShadowToBeRendered() const override;
 
     void layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const override;
 
     Xcb::Property fetchFirstInTabBox() const;
     void readFirstInTabBox(Xcb::Property &property);
     void updateFirstInTabBox();
     Xcb::StringProperty fetchColorScheme() const;
     void readColorScheme(Xcb::StringProperty &property);
     void updateColorScheme() override;
 
     //sets whether the client should be faked as being on all activities (and be shown during session save)
     void setSessionActivityOverride(bool needed);
     bool isClient() const override;
 
     template <typename T>
     void print(T &stream) const;
 
     void cancelFocusOutTimer();
 
     /**
      * Restores the Client after it had been hidden due to show on screen edge functionality.
      * In addition the property gets deleted so that the Client knows that it is visible again.
      */
     void showOnScreenEdge() override;
 
     Xcb::StringProperty fetchApplicationMenuServiceName() const;
     void readApplicationMenuServiceName(Xcb::StringProperty &property);
     void checkApplicationMenuServiceName();
 
     Xcb::StringProperty fetchApplicationMenuObjectPath() const;
     void readApplicationMenuObjectPath(Xcb::StringProperty &property);
     void checkApplicationMenuObjectPath();
 
     struct SyncRequest {
         xcb_sync_counter_t counter;
         xcb_sync_int64_t value;
         xcb_sync_alarm_t alarm;
         xcb_timestamp_t lastTimestamp;
         QTimer *timeout, *failsafeTimeout;
         bool isPending;
     };
     const SyncRequest &syncRequest() const {
         return m_syncRequest;
     }
     virtual bool wantsSyncCounter() const;
     void handleSync();
 
     static void cleanupX11();
 
 public Q_SLOTS:
     void closeWindow() override;
     void updateCaption() override;
 
-private Q_SLOTS:
-    void shadeHover();
-    void shadeUnhover();
-
 private:
     // Handlers for X11 events
     bool mapRequestEvent(xcb_map_request_event_t *e);
     void unmapNotifyEvent(xcb_unmap_notify_event_t *e);
     void destroyNotifyEvent(xcb_destroy_notify_event_t *e);
     void configureRequestEvent(xcb_configure_request_event_t *e);
     void propertyNotifyEvent(xcb_property_notify_event_t *e) override;
     void clientMessageEvent(xcb_client_message_event_t *e) override;
     void enterNotifyEvent(xcb_enter_notify_event_t *e);
     void leaveNotifyEvent(xcb_leave_notify_event_t *e);
     void focusInEvent(xcb_focus_in_event_t *e);
     void focusOutEvent(xcb_focus_out_event_t *e);
     void damageNotifyEvent() override;
 
     bool buttonPressEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root, xcb_timestamp_t time = XCB_CURRENT_TIME);
     bool buttonReleaseEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root);
     bool motionNotifyEvent(xcb_window_t w, int state, int x, int y, int x_root, int y_root);
 
 protected:
     void debug(QDebug& stream) const override;
     void addDamage(const QRegion &damage) override;
     bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const override;
     void doSetActive() override;
     void doSetKeepAbove() override;
     void doSetKeepBelow() override;
+    void doSetShade(ShadeMode previousShadeMode) override;
     void doSetDesktop() override;
     void doMinimize() override;
     void doSetSkipPager() override;
     void doSetSkipTaskbar() override;
     void doSetSkipSwitcher() override;
     void doSetDemandsAttention() override;
     bool belongsToDesktop() const override;
     bool doStartMoveResize() override;
     void doPerformMoveResize() override;
     bool isWaitingForMoveResizeSync() const override;
     void doResizeSync() override;
     QSize resizeIncrements() const override;
     bool acceptsFocus() const override;
 
     //Signals for the scripting interface
     //Signals make an excellent way for communication
     //in between objects as compared to simple function
     //calls
 Q_SIGNALS:
     void clientManaging(KWin::X11Client *);
     void clientFullScreenSet(KWin::X11Client *, bool, bool);
 
     /**
      * Emitted whenever the Client want to show it menu
      */
     void showRequest();
     /**
      * Emitted whenever the Client's menu is closed
      */
     void menuHidden();
     /**
      * Emitted whenever the Client's menu is available
      */
     void appMenuAvailable();
     /**
      * Emitted whenever the Client's menu is unavailable
      */
     void appMenuUnavailable();
 
     /**
      * Emitted whenever the Client's block compositing state changes.
      */
     void blockingCompositingChanged(KWin::X11Client *client);
     void clientSideDecoratedChanged();
 
 private:
     void exportMappingState(int s);   // ICCCM 4.1.3.1, 4.1.4, NETWM 2.5.1
     bool isManaged() const; ///< Returns false if this client is not yet managed
     void updateAllowedActions(bool force = false);
     QRect fullscreenMonitorsArea(NETFullscreenMonitors topology) const;
     void changeMaximize(bool horizontal, bool vertical, bool adjust) override;
     void getWmNormalHints();
     void getMotifHints();
     void getIcons();
     void fetchName();
     void fetchIconicName();
     QString readName() const;
     void setCaption(const QString& s, bool force = false);
     bool hasTransientInternal(const X11Client *c, bool indirect, QList<const X11Client *> &set) const;
     void setShortcutInternal() override;
 
     void configureRequest(int value_mask, int rx, int ry, int rw, int rh, int gravity, bool from_tool);
     NETExtendedStrut strut() const;
     int checkShadeGeometry(int w, int h);
     void getSyncCounter();
     void sendSyncRequest();
     void leaveMoveResize() override;
     void positionGeometryTip() override;
     void grabButton(int mod);
     void ungrabButton(int mod);
     void resizeDecoration();
     void createDecoration(const QRect &oldgeom) override;
 
     void pingWindow();
     void killProcess(bool ask, xcb_timestamp_t timestamp = XCB_TIME_CURRENT_TIME);
     void updateUrgency();
     static void sendClientMessage(xcb_window_t w, xcb_atom_t a, xcb_atom_t protocol,
                                   uint32_t data1 = 0, uint32_t data2 = 0, uint32_t data3 = 0,
                                   xcb_timestamp_t timestamp = xTime());
 
     void embedClient(xcb_window_t w, xcb_visualid_t visualid, xcb_colormap_t colormap, uint8_t depth);
     void detectNoBorder();
     void destroyDecoration() override;
     void updateFrameExtents();
     void setClientFrameExtents(const NETStrut &strut);
 
     void internalShow();
     void internalHide();
     void internalKeep();
     void map();
     void unmap();
     void updateHiddenPreview();
 
     void updateInputShape();
     void updateServerGeometry();
     void updateWindowPixmap();
 
     xcb_timestamp_t readUserTimeMapTimestamp(const KStartupInfoId* asn_id, const KStartupInfoData* asn_data,
                                   bool session) const;
     xcb_timestamp_t readUserCreationTime() const;
     void startupIdChanged();
 
     void updateInputWindow();
 
     Xcb::Property fetchShowOnScreenEdge() const;
     void readShowOnScreenEdge(Xcb::Property &property);
     /**
      * Reads the property and creates/destroys the screen edge if required
      * and shows/hides the client.
      */
     void updateShowOnScreenEdge();
 
     Xcb::Window m_client;
     Xcb::Window m_wrapper;
     Xcb::Window m_frame;
     QStringList activityList;
     int m_activityUpdatesBlocked;
     bool m_blockedActivityUpdatesRequireTransients;
     Xcb::Window m_moveResizeGrabWindow;
     bool move_resize_has_keyboard_grab;
     bool m_managed;
 
     Xcb::GeometryHints m_geometryHints;
     void sendSyntheticConfigureNotify();
     enum MappingState {
         Withdrawn, ///< Not handled, as per ICCCM WithdrawnState
         Mapped, ///< The frame is mapped
         Unmapped, ///< The frame is not mapped
         Kept ///< The frame should be unmapped, but is kept (For compositing)
     };
     MappingState mapping_state;
 
     Xcb::TransientFor fetchTransient() const;
     void readTransientProperty(Xcb::TransientFor &transientFor);
     void readTransient();
     xcb_window_t verifyTransientFor(xcb_window_t transient_for, bool set);
     void addTransient(AbstractClient* cl) override;
     void removeTransient(AbstractClient* cl) override;
     void removeFromMainClients();
     void cleanGrouping();
     void checkGroupTransients();
     void setTransient(xcb_window_t new_transient_for_id);
     xcb_window_t m_transientForId;
     xcb_window_t m_originalTransientForId;
-    ShadeMode shade_mode;
     X11Client *shade_below;
     uint deleting : 1; ///< True when doing cleanup and destroying the client
     Xcb::MotifHints m_motif;
     uint hidden : 1; ///< Forcibly hidden by calling hide()
     uint noborder : 1;
     uint app_noborder : 1; ///< App requested no border via window type, shape extension, etc.
     uint ignore_focus_stealing : 1; ///< Don't apply focus stealing prevention to this client
     bool blocks_compositing;
 
     enum FullScreenMode {
         FullScreenNone,
         FullScreenNormal
     } m_fullscreenMode;
 
     MaximizeMode max_mode;
     QRect m_bufferGeometry = QRect(0, 0, 100, 100);
     QRect m_clientGeometry = QRect(0, 0, 100, 100);
     QRect geom_fs_restore;
-    QTimer* shadeHoverTimer;
     xcb_colormap_t m_colormap;
     QString cap_normal, cap_iconic, cap_suffix;
     Group* in_group;
     QTimer* ping_timer;
     qint64 m_killHelperPID;
     xcb_timestamp_t m_pingTimestamp;
     xcb_timestamp_t m_userTime;
     NET::Actions allowed_actions;
     bool shade_geometry_change;
     SyncRequest m_syncRequest;
     static bool check_active_modal; ///< \see X11Client::checkActiveModal()
     int sm_stacking_order;
     friend struct ResetupRulesProcedure;
 
     friend bool performTransiencyCheck();
 
     Xcb::StringProperty fetchActivities() const;
     void readActivities(Xcb::StringProperty &property);
     void checkActivities();
     bool activitiesDefined; //whether the x property was actually set
 
     bool sessionActivityOverride;
     bool needsXWindowMove;
 
     Xcb::Window m_decoInputExtent;
     QPoint input_offset;
 
     QTimer *m_focusOutTimer;
 
     QList<QMetaObject::Connection> m_connections;
 
     QMetaObject::Connection m_edgeRemoveConnection;
     QMetaObject::Connection m_edgeGeometryTrackingConnection;
 
     QMargins m_clientFrameExtents;
 };
 
 inline xcb_window_t X11Client::wrapperId() const
 {
     return m_wrapper;
 }
 
 inline bool X11Client::isClientSideDecorated() const
 {
     return !m_clientFrameExtents.isNull();
 }
 
 inline bool X11Client::groupTransient() const
 {
     return m_transientForId == rootWindow();
 }
 
 // Needed because verifyTransientFor() may set transient_for_id to root window,
 // if the original value has a problem (window doesn't exist, etc.)
 inline bool X11Client::wasOriginallyGroupTransient() const
 {
     return m_originalTransientForId == rootWindow();
 }
 
 inline bool X11Client::isTransient() const
 {
     return m_transientForId != XCB_WINDOW_NONE;
 }
 
 inline const Group* X11Client::group() const
 {
     return in_group;
 }
 
 inline Group* X11Client::group()
 {
     return in_group;
 }
 
 inline bool X11Client::isShown(bool shaded_is_shown) const
 {
     return !isMinimized() && (!isShade() || shaded_is_shown) && !hidden;
 }
 
 inline bool X11Client::isHiddenInternal() const
 {
     return hidden;
 }
 
-inline ShadeMode X11Client::shadeMode() const
-{
-    return shade_mode;
-}
-
 inline MaximizeMode X11Client::maximizeMode() const
 {
     return max_mode;
 }
 
 inline bool X11Client::isFullScreen() const
 {
     return m_fullscreenMode != FullScreenNone;
 }
 
 inline bool X11Client::hasNETSupport() const
 {
     return info->hasNETSupport();
 }
 
 inline xcb_colormap_t X11Client::colormap() const
 {
     return m_colormap;
 }
 
 inline int X11Client::sessionStackingOrder() const
 {
     return sm_stacking_order;
 }
 
 inline bool X11Client::isManaged() const
 {
     return m_managed;
 }
 
 inline QSize X11Client::clientSize() const
 {
     return m_clientGeometry.size();
 }
 
 inline void X11Client::plainResize(const QSize& s, ForceGeometry_t force)
 {
     plainResize(s.width(), s.height(), force);
 }
 
 inline void X11Client::resizeWithChecks(const QSize &s, AbstractClient::ForceGeometry_t force)
 {
     resizeWithChecks(s.width(), s.height(), XCB_GRAVITY_BIT_FORGET, force);
 }
 
 inline void X11Client::resizeWithChecks(const QSize& s, xcb_gravity_t gravity, ForceGeometry_t force)
 {
     resizeWithChecks(s.width(), s.height(), gravity, force);
 }
 
 inline bool X11Client::hasUserTimeSupport() const
 {
     return info->userTime() != -1U;
 }
 
 inline xcb_window_t X11Client::moveResizeGrabWindow() const
 {
     return m_moveResizeGrabWindow;
 }
 
 inline bool X11Client::hiddenPreview() const
 {
     return mapping_state == Kept;
 }
 
 template <typename T>
 inline void X11Client::print(T &stream) const
 {
     stream << "\'Client:" << window() << ";WMCLASS:" << resourceClass() << ":"
            << resourceName() << ";Caption:" << caption() << "\'";
 }
 
 } // namespace
 Q_DECLARE_METATYPE(KWin::X11Client *)
 Q_DECLARE_METATYPE(QList<KWin::X11Client *>)