diff --git a/abstract_client.h b/abstract_client.h
index 01545ea0c..1b7cbb746 100644
--- a/abstract_client.h
+++ b/abstract_client.h
@@ -1,1266 +1,1263 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_CLIENT_H
 #define KWIN_ABSTRACT_CLIENT_H
 
 #include "toplevel.h"
 #include "options.h"
 #include "rules.h"
 #include "tabgroup.h"
 #include "cursor.h"
 
 #include <memory>
 
 #include <QElapsedTimer>
 #include <QPointer>
 
 namespace KWayland
 {
 namespace Server
 {
 class PlasmaWindowInterface;
 }
 }
 
 namespace KDecoration2
 {
 class Decoration;
 }
 
 namespace KWin
 {
 
 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 the currently visible Client in its Client Group (Window Tabs).
      * For change connect to the visibleChanged signal on the Client's Group.
      **/
     Q_PROPERTY(bool isCurrentTab READ isCurrentTab)
     /**
      * 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 http://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 geometryChanged signal
      * might be emitted at each resize step or only at the end of the resize operation.
      **/
     Q_PROPERTY(QRect geometry READ geometry WRITE setGeometry)
     /**
      * 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 "Window Tabs" Group this Client belongs to.
      **/
     Q_PROPERTY(KWin::TabGroup* tabGroup READ tabGroup NOTIFY tabGroupChanged SCRIPTABLE false)
 
     /**
      * 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:
     virtual ~AbstractClient();
 
     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;
 
     QPoint clientPos() const override {
         return QPoint(borderLeft(), borderTop());
     }
 
     virtual void updateMouseGrab();
     /**
      * @returns The caption consisting of @link{captionNormal} and @link{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;
     bool isFullScreenable() const;
     bool isFullScreenable(bool fullscreen_hack) const;
     virtual bool isFullScreen() const = 0;
     // 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 removeTransient(AbstractClient* cl);
     virtual QList<AbstractClient*> mainClients() const; // Call once before loop , is not indirect
     QList<AbstractClient*> allMainClients() const; // Call once before loop , is indirect
     /**
      * Returns true for "special" windows and false for windows which are "normal"
      * (normal=window which has a border, can be moved by the user, can be closed, etc.)
      * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
      * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
      */
     bool isSpecialWindow() const;
     void sendToScreen(int screen);
     const QKeySequence &shortcut() const {
         return _shortcut;
     }
     void setShortcut(const QString &cut);
     virtual bool performMouseCommand(Options::MouseCommand, const QPoint &globalPos);
     void setOnAllDesktops(bool set);
     void setDesktop(int);
     void enterDesktop(VirtualDesktop *desktop);
     void leaveDesktop(VirtualDesktop *desktop);
     void setDesktops(QVector<VirtualDesktop *> desktops);
 
     int desktop() const override {
         return m_desktops.isEmpty() ? (int)NET::OnAllDesktops : m_desktops.last()->x11DesktopNumber();
     }
     virtual QVector<VirtualDesktop *> desktops() const {
         return m_desktops;
     }
-    void removeDesktop(VirtualDesktop *desktop) {
-        m_desktops.removeAll(desktop);
-    }
     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) = 0;
     // Tabbing functions
     Q_INVOKABLE inline bool tabBefore(AbstractClient *other, bool activate) { return tabTo(other, false, activate); }
     Q_INVOKABLE inline bool tabBehind(AbstractClient *other, bool activate) { return tabTo(other, true, activate); }
     /**
      * Syncs the *dynamic* @param property @param fromThisClient or the @link currentTab() to
      * all members of the @link tabGroup() (if there is one)
      *
      * eg. if you call:
      * client->setProperty("kwin_tiling_floats", true);
      * client->syncTabGroupFor("kwin_tiling_floats", true)
      * all clients in this tabGroup will have ::property("kwin_tiling_floats").toBool() == true
      *
      * WARNING: non dynamic properties are ignored - you're not supposed to alter/update such explicitly
      */
     Q_INVOKABLE void syncTabGroupFor(QString property, bool fromThisClient = false);
     TabGroup *tabGroup() const;
     /**
      * Set tab group - this is to be invoked by TabGroup::add/remove(client) and NO ONE ELSE
      */
     void setTabGroup(TabGroup* group);
     virtual void setClientShown(bool shown);
     Q_INVOKABLE bool untab(const QRect &toGeometry = QRect(), bool clientRemoved = false);
     /*
     *   When a click is done in the decoration and it calls the group
     *   to change the visible client it starts to move-resize the new
     *   client, this function stops it.
     */
     bool isCurrentTab() const;
     virtual QRect geometryRestore() const = 0;
     /**
      * The currently applied maximize mode
      */
     virtual MaximizeMode maximizeMode() const = 0;
     /**
      * The maximise mode requested by the server.
      * For X this always matches maximizeMode, for wayland clients it
      * is asyncronous
      */
     virtual MaximizeMode requestedMaximizeMode() const;
     void maximize(MaximizeMode);
     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;
     virtual bool isResizable() const = 0;
     virtual bool isMovable() const = 0;
     virtual bool isMovableAcrossScreens() const = 0;
     /**
      * @c true only for @c ShadeNormal
      **/
     bool isShade() const {
         return shadeMode() == ShadeNormal;
     }
     /**
      * Default implementation returns @c ShadeNone
      **/
     virtual ShadeMode shadeMode() const; // Prefer isShade()
     void setShade(bool set);
     /**
      * Default implementation does nothing
      **/
     virtual void setShade(ShadeMode mode);
     /**
      * Whether the Client can be shaded. Default implementation returns @c false.
      **/
     virtual bool isShadeable() const;
     virtual bool isMaximizable() const = 0;
     virtual bool isMinimizable() const = 0;
     virtual QRect iconGeometry() const;
     virtual bool userCanSetFullScreen() const = 0;
     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();
     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);
 
     /** Set 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.
      */
     void setQuickTileMode(QuickTileMode mode, bool keyboard = false);
     QuickTileMode quickTileMode() const {
         return QuickTileMode(m_quickTileMode);
     }
     Layer layer() const override;
     void updateLayer();
 
     enum ForceGeometry_t { NormalGeometrySet, ForceGeometrySet };
     void move(int x, int y, ForceGeometry_t force = NormalGeometrySet);
     void move(const QPoint &p, ForceGeometry_t force = NormalGeometrySet);
     virtual void resizeWithChecks(int w, int h, ForceGeometry_t force = NormalGeometrySet) = 0;
     void resizeWithChecks(const QSize& s, ForceGeometry_t force = NormalGeometrySet);
     void keepInArea(QRect area, bool partial = false);
     virtual QSize minSize() const;
     virtual QSize maxSize() const;
     virtual void setGeometry(int x, int y, int w, int h, ForceGeometry_t force = NormalGeometrySet) = 0;
     void setGeometry(const QRect& r, ForceGeometry_t force = NormalGeometrySet);
     /// How to resize the window in order to obey constains (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
     };
     /**
      *Calculate the appropriate frame size for the given client size @p wsize.
      *
      * @p wsize is adapted according to the window's size hints (minimum, maximum and incremental size changes).
      *
      * Default implementation returns the passed in @p wsize.
      */
     virtual QSize sizeForClientSize(const QSize &wsize, Sizemode mode = SizemodeAny, bool noframe = false) const;
 
     QSize adjustedSize(const QSize&, Sizemode mode = SizemodeAny) const;
     QSize adjustedSize() const;
 
     bool isMove() const {
         return isMoveResize() && moveResizePointerMode() == PositionCenter;
     }
     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;
 
     /**
      * Restores the AbstractClient after it had been hidden due to show on screen edge functionality.
      * The AbstractClient also gets raised (e.g. Panel mode windows can cover) and the AbstractClient
      * gets informed in a window specific way that it is shown and raised again.
      **/
     virtual void showOnScreenEdge() = 0;
 
     QByteArray desktopFileName() const {
         return m_desktopFileName;
     }
 
     /**
      * Tries to terminate the process of this AbstractClient.
      *
      * Implementing subclasses can perform a windowing system solution for terminating.
      **/
     virtual void killWindow() = 0;
 
     enum class SameApplicationCheck {
         RelaxedForActive = 1 << 0,
         AllowCrossProcesses = 1 << 1
     };
     Q_DECLARE_FLAGS(SameApplicationChecks, SameApplicationCheck)
     static bool belongToSameApplication(const AbstractClient* c1, const AbstractClient* c2, SameApplicationChecks checks = SameApplicationChecks());
 
     bool hasApplicationMenu() const;
     bool applicationMenuActive() const {
         return m_applicationMenuActive;
     }
     void setApplicationMenuActive(bool applicationMenuActive);
 
     QString applicationMenuServiceName() const {
         return m_applicationMenuServiceName;
     }
     QString applicationMenuObjectPath() const {
         return m_applicationMenuObjectPath;
     }
     QString colorScheme() const {
         return m_colorScheme;
     }
 
     /**
      * Request showing the application menu bar
      * @param actionId The DBus menu ID of the action that should be highlighted, 0 for the root menu
      */
     void showApplicationMenu(int actionId);
 
     bool unresponsive() const;
 
     virtual bool isInitialPositionSet() const {
         return false;
     }
 
 public Q_SLOTS:
     virtual void closeWindow() = 0;
 
 Q_SIGNALS:
     void fullScreenChanged();
     void skipTaskbarChanged();
     void skipPagerChanged();
     void skipSwitcherChanged();
     void iconChanged();
     void activeChanged();
     void keepAboveChanged(bool);
     void keepBelowChanged(bool);
     /**
      * Emitted whenever the demands attention state changes.
      **/
     void demandsAttentionChanged();
     void desktopPresenceChanged(KWin::AbstractClient*, int); // to be forwarded by Workspace
     void desktopChanged();
     void x11DesktopIdsChanged();
     void shadeChanged();
     void minimizedChanged();
     void clientMinimized(KWin::AbstractClient* client, bool animate);
     void clientUnminimized(KWin::AbstractClient* client, bool animate);
     void paletteChanged(const QPalette &p);
     void colorSchemeChanged();
     void captionChanged();
     void clientMaximizedStateChanged(KWin::AbstractClient*, MaximizeMode);
     void clientMaximizedStateChanged(KWin::AbstractClient* c, bool h, bool v);
     void transientChanged();
     void modalChanged();
     void quickTileModeChanged();
     void moveResizedChanged();
     void moveResizeCursorChanged(CursorShape);
     void clientStartUserMovedResized(KWin::AbstractClient*);
     void clientStepUserMovedResized(KWin::AbstractClient *, const QRect&);
     void clientFinishUserMovedResized(KWin::AbstractClient*);
     void closeableChanged(bool);
     void minimizeableChanged(bool);
     void shadeableChanged(bool);
     void maximizeableChanged(bool);
     void desktopFileNameChanged();
     void hasApplicationMenuChanged(bool);
     void applicationMenuActiveChanged(bool);
     void unresponsiveChanged(bool);
     /**
      * Emitted whenever the Client's TabGroup changed. That is whenever the Client is moved to
      * another group, but not when a Client gets added or removed to the Client's ClientGroup.
      **/
     void tabGroupChanged();
 
 protected:
     AbstractClient();
     void setFirstInTabBox(bool enable) {
         m_firstInTabBox = enable;
     }
     void setIcon(const QIcon &icon);
     void startAutoRaise();
     void autoRaise();
     /**
      * Whether the window accepts focus.
      * The difference to wantsInput is that the implementation should not check rules and return
      * what the window effectively supports.
      **/
     virtual bool acceptsFocus() const = 0;
     /**
      * Called from ::setActive once the active value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      **/
     virtual void doSetActive();
     /**
      * Called from ::setKeepAbove once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      **/
     virtual void doSetKeepAbove();
     /**
      * Called from ::setKeepBelow once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      **/
     virtual void doSetKeepBelow();
     /**
      * Called from ::setDeskop once the desktop value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      * @param desktop The new desktop the Client is on
      * @param was_desk The desktop the Client was on before
      **/
     virtual void doSetDesktop(int desktop, int was_desk);
     /**
      * Called from ::minimize and ::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();
 
     void setupWindowManagementInterface();
     void destroyWindowManagementInterface();
 
     void updateColorScheme(QString path);
     virtual void updateColorScheme() = 0;
 
     void setTransientFor(AbstractClient *transientFor);
     virtual void addTransient(AbstractClient* cl);
     /**
      * Just removes the @p cl from the transients without any further checks.
      **/
     void removeTransientFromList(AbstractClient* cl);
 
     Layer belongsToLayer() const;
     virtual bool belongsToDesktop() const;
     void invalidateLayer();
     bool isActiveFullScreen() const;
     virtual Layer layerForDock() const;
 
     // electric border / quick tiling
     void setElectricBorderMode(QuickTileMode mode);
     QuickTileMode electricBorderMode() const {
         return m_electricMode;
     }
     void setElectricBorderMaximizing(bool maximizing);
     bool isElectricBorderMaximizing() const {
         return m_electricMaximizing;
     }
     QRect electricBorderMaximizeGeometry(QPoint pos, int desktop);
     void updateQuickTileMode(QuickTileMode newMode) {
         m_quickTileMode = newMode;
     }
 
     KWayland::Server::PlasmaWindowInterface *windowManagementInterface() const {
         return m_windowManagementInterface;
     }
 
     // geometry handling
     void checkOffscreenPosition(QRect *geom, const QRect &screenArea);
     int borderLeft() const;
     int borderRight() const;
     int borderTop() const;
     int borderBottom() const;
     virtual void changeMaximize(bool horizontal, bool vertical, bool adjust) = 0;
     virtual void setGeometryRestore(const QRect &geo) = 0;
     /**
      * 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 geometryBeforeUpdateBlocking() const {
         return m_geometryBeforeUpdateBlocking;
     }
     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();
 
     /**
      * Convenient method to update the TabGroup states if there is one present.
      * Marked as virtual as TabGroup does not yet handle AbstractClient, but only
      * subclasses of AbstractClient. Given that the default implementation does nothing.
      **/
     virtual void updateTabGroupStates(TabGroup::States states);
 
     /**
      * @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 @link startMoveResize.
      *
      * Implementing classes should return @c false if starting move resize should
      * get aborted. In that case @link startMoveResize will also return @c false.
      *
      * Base implementation returns @c true.
      **/
     virtual bool doStartMoveResize();
     void finishMoveResize(bool cancel);
     /**
      * Leaves the move resize mode.
      *
      * Inheriting classes must invoke the base implementation which
      * ensures that the internal mode is properly ended.
      **/
     virtual void leaveMoveResize();
     virtual void positionGeometryTip();
     void performMoveResize();
     /**
      * Called from performMoveResize() after actually performing the change of geometry.
      * Implementing subclasses can perform windowing system specific handling here.
      *
      * Default implementation does nothing.
      **/
     virtual void doPerformMoveResize();
     /*
      * Checks if the mouse cursor is near the edge of the screen and if so
      * activates quick tiling or maximization
      */
     void checkQuickTilingMaximizationZones(int xroot, int yroot);
     /**
      * Whether a sync request is still pending.
      * Default implementation returns @c false.
      **/
     virtual bool isWaitingForMoveResizeSync() const;
     /**
      * Called during handling a resize. Implementing subclasses can use this
      * method to perform windowing system specific syncing.
      *
      * Default implementation does nothing.
      **/
     virtual void doResizeSync();
     void handleMoveResize(int x, int y, int x_root, int y_root);
     void handleMoveResize(const QPoint &local, const QPoint &global);
     void dontMoveResize();
 
     virtual QSize resizeIncrements() const;
 
     /**
      * Returns the position depending on the Decoration's section under mouse.
      * If no decoration it returns PositionCenter.
      **/
     Position mousePosition() const;
 
     static bool haveResizeEffect() {
         return s_haveResizeEffect;
     }
     static void updateHaveResizeEffect();
     static void resetHaveResizeEffect() {
         s_haveResizeEffect = false;
     }
 
     void setDecoration(KDecoration2::Decoration *decoration) {
         m_decoration.decoration = decoration;
     }
     virtual void destroyDecoration();
     void startDecorationDoubleClickTimer();
     void invalidateDecorationDoubleClickTimer();
 
     void setDesktopFileName(QByteArray name);
     QString iconFromDesktopFile() const;
 
     void updateApplicationMenuServiceName(const QString &serviceName);
     void updateApplicationMenuObjectPath(const QString &objectPath);
 
     void setUnresponsive(bool unresponsive);
 
     virtual void setShortcutInternal();
     QString shortcutCaptionSuffix() const;
     virtual void updateCaption() = 0;
 
     /**
      * Looks for another AbstractClient with same @link{captionNormal} and @link{captionSuffix}.
      * If no such AbstractClient exists @c nullptr is returned.
      **/
     AbstractClient *findClientWithSameCaption() const;
 
     void finishWindowRules();
     void discardTemporaryRules();
 
     bool tabTo(AbstractClient *other, bool behind, bool activate);
 
 private:
     void handlePaletteChange();
     QSharedPointer<TabBox::TabBoxClientImpl> m_tabBoxClient;
     bool m_firstInTabBox = false;
     bool m_skipTaskbar = false;
     /**
      * Unaffected by KWin
      **/
     bool m_originalSkipTaskbar = false;
     bool m_skipPager = false;
     bool m_skipSwitcher = false;
     QIcon m_icon;
     bool m_active = false;
     bool m_keepAbove = false;
     bool m_keepBelow = false;
     bool m_demandsAttention = false;
     bool m_minimized = false;
     QTimer *m_autoRaiseTimer = nullptr;
     QVector <VirtualDesktop *> m_desktops;
 
     QString m_colorScheme;
     std::shared_ptr<Decoration::DecorationPalette> m_palette;
     static QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> s_palettes;
     static std::shared_ptr<Decoration::DecorationPalette> s_defaultPalette;
 
     KWayland::Server::PlasmaWindowInterface *m_windowManagementInterface = nullptr;
 
     AbstractClient *m_transientFor = nullptr;
     QList<AbstractClient*> m_transients;
     bool m_modal = false;
     Layer m_layer = UnknownLayer;
 
     // electric border/quick tiling
     QuickTileMode m_electricMode = QuickTileFlag::None;
     bool m_electricMaximizing = false;
     /** The quick tile mode of this window.
      */
     int m_quickTileMode = int(QuickTileFlag::None);
     QTimer *m_electricMaximizingDelay = nullptr;
 
     // geometry
     int m_blockGeometryUpdates = 0; // > 0 = New geometry is remembered, but not actually set
     PendingGeometry_t m_pendingGeometryUpdate = PendingGeometryNone;
     friend class GeometryUpdatesBlocker;
     QRect m_visibleRectBeforeGeometryUpdate;
     QRect m_geometryBeforeUpdateBlocking;
 
     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;
     TabGroup* tab_group = nullptr;
 
     static bool s_haveResizeEffect;
 };
 
 /**
  * Helper for AbstractClient::blockGeometryUpdates() being called in pairs (true/false)
  */
 class GeometryUpdatesBlocker
 {
 public:
     explicit GeometryUpdatesBlocker(AbstractClient* c)
         : cl(c) {
         cl->blockGeometryUpdates(true);
     }
     ~GeometryUpdatesBlocker() {
         cl->blockGeometryUpdates(false);
     }
 
 private:
     AbstractClient* cl;
 };
 
 inline void AbstractClient::move(const QPoint& p, ForceGeometry_t force)
 {
     move(p.x(), p.y(), force);
 }
 
 inline void AbstractClient::resizeWithChecks(const QSize& s, AbstractClient::ForceGeometry_t force)
 {
     resizeWithChecks(s.width(), s.height(), force);
 }
 
 inline void AbstractClient::setGeometry(const QRect& r, ForceGeometry_t force)
 {
     setGeometry(r.x(), r.y(), r.width(), r.height(), force);
 }
 
 inline const QList<AbstractClient*>& AbstractClient::transients() const
 {
     return m_transients;
 }
 
 inline bool AbstractClient::areGeometryUpdatesBlocked() const
 {
     return m_blockGeometryUpdates != 0;
 }
 
 inline void AbstractClient::blockGeometryUpdates()
 {
     m_blockGeometryUpdates++;
 }
 
 inline void AbstractClient::unblockGeometryUpdates()
 {
     m_blockGeometryUpdates--;
 }
 
 inline AbstractClient::PendingGeometry_t AbstractClient::pendingGeometryUpdate() const
 {
     return m_pendingGeometryUpdate;
 }
 
 inline void AbstractClient::setPendingGeometryUpdate(PendingGeometry_t update)
 {
     m_pendingGeometryUpdate = update;
 }
 
 inline TabGroup* AbstractClient::tabGroup() const
 {
     return tab_group;
 }
 
 }
 
 Q_DECLARE_METATYPE(KWin::AbstractClient*)
 Q_DECLARE_METATYPE(QList<KWin::AbstractClient*>)
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AbstractClient::SameApplicationChecks)
 
 #endif
diff --git a/workspace.cpp b/workspace.cpp
index 734e3fdc0..43a3035d6 100644
--- a/workspace.cpp
+++ b/workspace.cpp
@@ -1,1770 +1,1773 @@
 /********************************************************************
  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 "workspace.h"
 // kwin libs
 #include <kwinglplatform.h>
 // kwin
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "appmenu.h"
 #include "atoms.h"
 #include "client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "dbusinterface.h"
 #include "deleted.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "group.h"
 #include "input.h"
 #include "logind.h"
 #include "moving_client_x11_filter.h"
 #include "killwindow.h"
 #include "netinfo.h"
 #include "outline.h"
 #include "placement.h"
 #include "rules.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "platform.h"
 #include "scripting/scripting.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "unmanaged.h"
 #include "useractions.h"
 #include "virtualdesktops.h"
 #include "shell_client.h"
 #include "was_user_interaction_x11_filter.h"
 #include "wayland_server.h"
 #include "xcbutils.h"
 #include "main.h"
 #include "decorations/decorationbridge.h"
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KStartupInfo>
 // Qt
 #include <QtConcurrentRun>
 
 namespace KWin
 {
 
 extern int screen_number;
 extern bool is_multihead;
 
 ColorMapper::ColorMapper(QObject *parent)
     : QObject(parent)
     , m_default(defaultScreen()->default_colormap)
     , m_installed(defaultScreen()->default_colormap)
 {
 }
 
 ColorMapper::~ColorMapper()
 {
 }
 
 void ColorMapper::update()
 {
     xcb_colormap_t cmap = m_default;
     if (Client *c = dynamic_cast<Client*>(Workspace::self()->activeClient())) {
         if (c->colormap() != XCB_COLORMAP_NONE) {
             cmap = c->colormap();
         }
     }
     if (cmap != m_installed) {
         xcb_install_colormap(connection(), cmap);
         m_installed = cmap;
     }
 }
 
 Workspace* Workspace::_self = 0;
 
 Workspace::Workspace(const QString &sessionKey)
     : QObject(0)
     , m_compositor(NULL)
     // Unsorted
     , active_popup(NULL)
     , active_popup_client(NULL)
     , m_initialDesktop(1)
     , active_client(0)
     , last_active_client(0)
     , most_recently_raised(0)
     , movingClient(0)
     , delayfocus_client(0)
     , force_restacking(false)
     , showing_desktop(false)
     , was_user_interaction(false)
     , session_saving(false)
     , block_focus(0)
     , m_userActionsMenu(new UserActionsMenu(this))
     , client_keys_dialog(NULL)
     , client_keys_client(NULL)
     , global_shortcuts_disabled_for_client(false)
     , workspaceInit(true)
     , startup(0)
     , set_active_client_recursion(0)
     , block_stacking_updates(0)
 {
     // If KWin was already running it saved its configuration after loosing the selection -> Reread
     QFuture<void> reparseConfigFuture = QtConcurrent::run(options, &Options::reparseConfiguration);
 
     ApplicationMenu::create(this);
 
     _self = this;
 
 #ifdef KWIN_BUILD_ACTIVITIES
     Activities *activities = nullptr;
     if (kwinApp()->usesKActivities()) {
         activities = Activities::create(this);
     }
     if (activities) {
         connect(activities, SIGNAL(currentChanged(QString)), SLOT(updateCurrentActivity(QString)));
     }
 #endif
 
     // PluginMgr needs access to the config file, so we need to wait for it for finishing
     reparseConfigFuture.waitForFinished();
 
     options->loadConfig();
     options->loadCompositingConfig(false);
 
     delayFocusTimer = 0;
 
     if (!sessionKey.isEmpty())
         loadSessionInfo(sessionKey);
     connect(qApp, &QGuiApplication::commitDataRequest, this, &Workspace::commitData);
     connect(qApp, &QGuiApplication::saveStateRequest, this, &Workspace::saveState);
 
     RuleBook::create(this)->load();
 
     ScreenEdges::create(this);
 
     // VirtualDesktopManager needs to be created prior to init shortcuts
     // and prior to TabBox, due to TabBox connecting to signals
     // actual initialization happens in init()
     VirtualDesktopManager::create(this);
     //dbus interface
     new VirtualDesktopManagerDBusInterface(VirtualDesktopManager::self());
 
 #ifdef KWIN_BUILD_TABBOX
     // need to create the tabbox before compositing scene is setup
     TabBox::TabBox::create(this);
 #endif
 
     if (Compositor::self()) {
         m_compositor = Compositor::self();
     } else {
         m_compositor = Compositor::create(this);
     }
     connect(this, &Workspace::currentDesktopChanged, m_compositor, &Compositor::addRepaintFull);
     connect(m_compositor, &QObject::destroyed, this, [this] { m_compositor = nullptr; });
 
     auto decorationBridge = Decoration::DecorationBridge::create(this);
     decorationBridge->init();
     connect(this, &Workspace::configChanged, decorationBridge, &Decoration::DecorationBridge::reconfigure);
 
     new DBusInterface(this);
 
     Outline::create(this);
 
     initShortcuts();
 
     init();
 }
 
 void Workspace::init()
 {
     KSharedConfigPtr config = kwinApp()->config();
     kwinApp()->createScreens();
     Screens *screens = Screens::self();
     // get screen support
     connect(screens, SIGNAL(changed()), SLOT(desktopResized()));
     screens->setConfig(config);
     screens->reconfigure();
     connect(options, SIGNAL(configChanged()), screens, SLOT(reconfigure()));
     ScreenEdges *screenEdges = ScreenEdges::self();
     screenEdges->setConfig(config);
     screenEdges->init();
     connect(options, SIGNAL(configChanged()), screenEdges, SLOT(reconfigure()));
     connect(VirtualDesktopManager::self(), SIGNAL(layoutChanged(int,int)), screenEdges, SLOT(updateLayout()));
     connect(this, &Workspace::clientActivated, screenEdges, &ScreenEdges::checkBlocking);
 
     FocusChain *focusChain = FocusChain::create(this);
     connect(this, &Workspace::clientRemoved, focusChain, &FocusChain::remove);
     connect(this, &Workspace::clientActivated, focusChain, &FocusChain::setActiveClient);
     connect(VirtualDesktopManager::self(), SIGNAL(countChanged(uint,uint)), focusChain, SLOT(resize(uint,uint)));
     connect(VirtualDesktopManager::self(), SIGNAL(currentChanged(uint,uint)), focusChain, SLOT(setCurrentDesktop(uint,uint)));
     connect(options, SIGNAL(separateScreenFocusChanged(bool)), focusChain, SLOT(setSeparateScreenFocus(bool)));
     focusChain->setSeparateScreenFocus(options->isSeparateScreenFocus());
 
     // create VirtualDesktopManager and perform dependency injection
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(vds, &VirtualDesktopManager::desktopRemoved, this,
         [this](KWin::VirtualDesktop *desktop) {
             //Wayland
             if (kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
                 kwinApp()->operationMode() == Application::OperationModeXwayland) {
                 for (auto it = m_allClients.constBegin(); it != m_allClients.constEnd(); ++it) {
-                    const bool needsMove = (*it)->desktops().count() == 1;
-                    (*it)->removeDesktop(desktop);
-                    if (needsMove) {
+                    if (!(*it)->desktops().contains(desktop)) {
+                        continue;
+                    }
+                    if ((*it)->desktops().count() > 1) {
+                        (*it)->leaveDesktop(desktop);
+                    } else {
                         sendClientToDesktop(*it, qMin(desktop->x11DesktopNumber(), VirtualDesktopManager::self()->count()), true);
                     }
                 }
             //X11
             } else {
                 for (auto it = m_allClients.constBegin(); it != m_allClients.constEnd(); ++it) {
                     if (!(*it)->isOnAllDesktops() && ((*it)->desktop() > static_cast<int>(VirtualDesktopManager::self()->count()))) {
                         sendClientToDesktop(*it, VirtualDesktopManager::self()->count(), true);
                     }
                 }
             }
         }
     );
 
     connect(vds, SIGNAL(countChanged(uint,uint)), SLOT(slotDesktopCountChanged(uint,uint)));
     connect(vds, SIGNAL(currentChanged(uint,uint)), SLOT(slotCurrentDesktopChanged(uint,uint)));
     vds->setNavigationWrappingAround(options->isRollOverDesktops());
     connect(options, SIGNAL(rollOverDesktopsChanged(bool)), vds, SLOT(setNavigationWrappingAround(bool)));
     vds->setConfig(config);
 
     // Now we know how many desktops we'll have, thus we initialize the positioning object
     Placement::create(this);
 
     // positioning object needs to be created before the virtual desktops are loaded.
     vds->load();
     vds->updateLayout();
     //makes sure any autogenerated id is saved, necessary as in case of xwayland, load will be called 2 times
     // load is needed to be called again when starting xwayalnd to sync to RootInfo, see BUG 385260
     vds->save();
 
     if (!VirtualDesktopManager::self()->setCurrent(m_initialDesktop))
         VirtualDesktopManager::self()->setCurrent(1);
 
     reconfigureTimer.setSingleShot(true);
     updateToolWindowsTimer.setSingleShot(true);
 
     connect(&reconfigureTimer, SIGNAL(timeout()), this, SLOT(slotReconfigure()));
     connect(&updateToolWindowsTimer, SIGNAL(timeout()), this, SLOT(slotUpdateToolWindows()));
 
     // TODO: do we really need to reconfigure everything when fonts change?
     // maybe just reconfigure the decorations? Move this into libkdecoration?
     QDBusConnection::sessionBus().connect(QString(),
                                           QStringLiteral("/KDEPlatformTheme"),
                                           QStringLiteral("org.kde.KDEPlatformTheme"),
                                           QStringLiteral("refreshFonts"),
                                           this, SLOT(reconfigure()));
 
     active_client = NULL;
 
     initWithX11();
 
     Scripting::create(this);
 
     if (auto w = waylandServer()) {
         connect(w, &WaylandServer::shellClientAdded, this,
             [this] (ShellClient *c) {
                 setupClientConnections(c);
                 c->updateDecoration(false);
                 updateClientLayer(c);
                 if (!c->isInternal()) {
                     QRect area = clientArea(PlacementArea, Screens::self()->current(), c->desktop());
                     bool placementDone = false;
                     if (c->isInitialPositionSet()) {
                         placementDone = true;
                     }
                     if (c->isFullScreen()) {
                         placementDone = true;
                     }
                     if (!placementDone) {
                         c->placeIn(area);
                     }
                     m_allClients.append(c);
                     if (!unconstrained_stacking_order.contains(c))
                         unconstrained_stacking_order.append(c);   // Raise if it hasn't got any stacking position yet
                     if (!stacking_order.contains(c))    // It'll be updated later, and updateToolWindows() requires
                         stacking_order.append(c);      // c to be in stacking_order
                 }
                 markXStackingOrderAsDirty();
                 updateStackingOrder(true);
                 updateClientArea();
                 if (c->wantsInput() && !c->isMinimized()) {
                     activateClient(c);
                 }
                 connect(c, &ShellClient::windowShown, this,
                     [this, c] {
                         updateClientLayer(c);
                         // TODO: when else should we send the client through placement?
                         if (c->hasTransientPlacementHint()) {
                             QRect area = clientArea(PlacementArea, Screens::self()->current(), c->desktop());
                             c->placeIn(area);
                         }
                         markXStackingOrderAsDirty();
                         updateStackingOrder(true);
                         updateClientArea();
                         if (c->wantsInput()) {
                             activateClient(c);
                         }
                     }
                 );
                 connect(c, &ShellClient::windowHidden, this,
                     [this] {
                         markXStackingOrderAsDirty();
                         updateStackingOrder(true);
                         updateClientArea();
                     }
                 );
             }
         );
         connect(w, &WaylandServer::shellClientRemoved, this,
             [this] (ShellClient *c) {
                 m_allClients.removeAll(c);
                 if (c == most_recently_raised) {
                     most_recently_raised = nullptr;
                 }
                 if (c == delayfocus_client) {
                     cancelDelayFocus();
                 }
                 if (c == last_active_client) {
                     last_active_client = nullptr;
                 }
                 if (client_keys_client == c) {
                     setupWindowShortcutDone(false);
                 }
                 if (!c->shortcut().isEmpty()) {
                     c->setShortcut(QString());   // Remove from client_keys
                 }
                 clientHidden(c);
                 emit clientRemoved(c);
                 markXStackingOrderAsDirty();
                 updateStackingOrder(true);
                 updateClientArea();
             }
         );
     }
 
     // SELI TODO: This won't work with unreasonable focus policies,
     // and maybe in rare cases also if the selected client doesn't
     // want focus
     workspaceInit = false;
 
     // broadcast that Workspace is ready, but first process all events.
     QMetaObject::invokeMethod(this, "workspaceInitialized", Qt::QueuedConnection);
 
     // TODO: ungrabXServer()
 }
 
 void Workspace::initWithX11()
 {
     if (!kwinApp()->x11Connection()) {
         connect(kwinApp(), &Application::x11ConnectionChanged, this, &Workspace::initWithX11, Qt::UniqueConnection);
         return;
     }
     disconnect(kwinApp(), &Application::x11ConnectionChanged, this, &Workspace::initWithX11);
 
     atoms->retrieveHelpers();
 
     // first initialize the extensions
     Xcb::Extensions::self();
     ColorMapper *colormaps = new ColorMapper(this);
     connect(this, &Workspace::clientActivated, colormaps, &ColorMapper::update);
 
     // Call this before XSelectInput() on the root window
     startup = new KStartupInfo(
         KStartupInfo::DisableKWinModule | KStartupInfo::AnnounceSilenceChanges, this);
 
     // Select windowmanager privileges
     selectWmInputEventMask();
 
     // Compatibility
     int32_t data = 1;
 
     xcb_change_property(connection(), XCB_PROP_MODE_APPEND, rootWindow(), atoms->kwin_running,
                         atoms->kwin_running, 32, 1, &data);
 
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         m_wasUserInteractionFilter.reset(new WasUserInteractionX11Filter);
         m_movingClientFilter.reset(new MovingClientX11Filter);
     }
     updateXTime(); // Needed for proper initialization of user_time in Client ctor
 
     const uint32_t nullFocusValues[] = {true};
     m_nullFocus.reset(new Xcb::Window(QRect(-1, -1, 1, 1), XCB_WINDOW_CLASS_INPUT_ONLY, XCB_CW_OVERRIDE_REDIRECT, nullFocusValues));
     m_nullFocus->map();
 
     RootInfo *rootInfo = RootInfo::create();
     const auto vds = VirtualDesktopManager::self();
     vds->setRootInfo(rootInfo);
     // load again to sync to RootInfo, see BUG 385260
     vds->load();
     vds->updateRootInfo();
     rootInfo->setCurrentDesktop(vds->currentDesktop()->x11DesktopNumber());
 
     // TODO: only in X11 mode
     // Extra NETRootInfo instance in Client mode is needed to get the values of the properties
     NETRootInfo client_info(connection(), NET::ActiveWindow | NET::CurrentDesktop);
     if (!qApp->isSessionRestored())
         m_initialDesktop = client_info.currentDesktop();
     if (!VirtualDesktopManager::self()->setCurrent(m_initialDesktop))
         VirtualDesktopManager::self()->setCurrent(1);
 
     // TODO: better value
     rootInfo->setActiveWindow(None);
     focusToNull();
 
     if (!qApp->isSessionRestored())
         ++block_focus; // Because it will be set below
 
     {
         // Begin updates blocker block
         StackingUpdatesBlocker blocker(this);
 
         Xcb::Tree tree(rootWindow());
         xcb_window_t *wins = xcb_query_tree_children(tree.data());
 
         QVector<Xcb::WindowAttributes> windowAttributes(tree->children_len);
         QVector<Xcb::WindowGeometry> windowGeometries(tree->children_len);
 
         // Request the attributes and geometries of all toplevel windows
         for (int i = 0; i < tree->children_len; i++) {
             windowAttributes[i] = Xcb::WindowAttributes(wins[i]);
             windowGeometries[i] = Xcb::WindowGeometry(wins[i]);
         }
 
         // Get the replies
         for (int i = 0; i < tree->children_len; i++) {
             Xcb::WindowAttributes attr(windowAttributes.at(i));
 
             if (attr.isNull()) {
                 continue;
             }
 
             if (attr->override_redirect) {
                 if (attr->map_state == XCB_MAP_STATE_VIEWABLE &&
                     attr->_class != XCB_WINDOW_CLASS_INPUT_ONLY)
                     // ### This will request the attributes again
                     createUnmanaged(wins[i]);
             } else if (attr->map_state != XCB_MAP_STATE_UNMAPPED) {
                 if (Application::wasCrash()) {
                     fixPositionAfterCrash(wins[i], windowGeometries.at(i).data());
                 }
 
                 // ### This will request the attributes again
                 createClient(wins[i], true);
             }
         }
 
         // Propagate clients, will really happen at the end of the updates blocker block
         updateStackingOrder(true);
 
         saveOldScreenSizes();
         updateClientArea();
 
         // NETWM spec says we have to set it to (0,0) if we don't support it
         NETPoint* viewports = new NETPoint[VirtualDesktopManager::self()->count()];
         rootInfo->setDesktopViewport(VirtualDesktopManager::self()->count(), *viewports);
         delete[] viewports;
         QRect geom;
         for (int i = 0; i < screens()->count(); i++) {
             geom |= screens()->geometry(i);
         }
         NETSize desktop_geometry;
         desktop_geometry.width = geom.width();
         desktop_geometry.height = geom.height();
         rootInfo->setDesktopGeometry(desktop_geometry);
         setShowingDesktop(false);
 
     } // End updates blocker block
 
     // TODO: only on X11?
     AbstractClient* new_active_client = nullptr;
     if (!qApp->isSessionRestored()) {
         --block_focus;
         new_active_client = findClient(Predicate::WindowMatch, client_info.activeWindow());
     }
     if (new_active_client == NULL
             && activeClient() == NULL && should_get_focus.count() == 0) {
         // No client activated in manage()
         if (new_active_client == NULL)
             new_active_client = topClientOnDesktop(VirtualDesktopManager::self()->current(), -1);
         if (new_active_client == NULL && !desktops.isEmpty())
             new_active_client = findDesktop(true, VirtualDesktopManager::self()->current());
     }
     if (new_active_client != NULL)
         activateClient(new_active_client);
 }
 
 Workspace::~Workspace()
 {
     blockStackingUpdates(true);
 
     // TODO: grabXServer();
 
     // Use stacking_order, so that kwin --replace keeps stacking order
     const ToplevelList stack = stacking_order;
     // "mutex" the stackingorder, since anything trying to access it from now on will find
     // many dangeling pointers and crash
     stacking_order.clear();
 
     for (ToplevelList::const_iterator it = stack.constBegin(), end = stack.constEnd(); it != end; ++it) {
         Client *c = qobject_cast<Client*>(const_cast<Toplevel*>(*it));
         if (!c) {
             continue;
         }
         // Only release the window
         c->releaseWindow(true);
         // No removeClient() is called, it does more than just removing.
         // However, remove from some lists to e.g. prevent performTransiencyCheck()
         // from crashing.
         clients.removeAll(c);
         m_allClients.removeAll(c);
         desktops.removeAll(c);
     }
     Client::cleanupX11();
     for (UnmanagedList::iterator it = unmanaged.begin(), end = unmanaged.end(); it != end; ++it)
         (*it)->release(ReleaseReason::KWinShutsDown);
 
     if (auto c = kwinApp()->x11Connection()) {
         xcb_delete_property(c, kwinApp()->x11RootWindow(), atoms->kwin_running);
     }
 
     for (auto it = deleted.begin(); it != deleted.end();) {
         emit deletedRemoved(*it);
         it = deleted.erase(it);
     }
 
     delete RuleBook::self();
     kwinApp()->config()->sync();
 
     RootInfo::destroy();
     delete startup;
     delete Placement::self();
     delete client_keys_dialog;
     foreach (SessionInfo * s, session)
     delete s;
 
     // TODO: ungrabXServer();
 
     Xcb::Extensions::destroy();
     _self = 0;
 }
 
 void Workspace::setupClientConnections(AbstractClient *c)
 {
     connect(c, &Toplevel::needsRepaint, m_compositor, &Compositor::scheduleRepaint);
     connect(c, &AbstractClient::desktopPresenceChanged, this, &Workspace::desktopPresenceChanged);
     connect(c, &AbstractClient::minimizedChanged, this, std::bind(&Workspace::clientMinimizedChanged, this, c));
 }
 
 Client* Workspace::createClient(xcb_window_t w, bool is_mapped)
 {
     StackingUpdatesBlocker blocker(this);
     Client* c = new Client();
     setupClientConnections(c);
     connect(c, SIGNAL(blockingCompositingChanged(KWin::Client*)), m_compositor, SLOT(updateCompositeBlocking(KWin::Client*)));
     connect(c, SIGNAL(clientFullScreenSet(KWin::Client*,bool,bool)), ScreenEdges::self(), SIGNAL(checkBlocking()));
     if (!c->manage(w, is_mapped)) {
         Client::deleteClient(c);
         return NULL;
     }
     addClient(c);
     return c;
 }
 
 Unmanaged* Workspace::createUnmanaged(xcb_window_t w)
 {
     if (m_compositor && m_compositor->checkForOverlayWindow(w))
         return NULL;
     Unmanaged* c = new Unmanaged();
     if (!c->track(w)) {
         Unmanaged::deleteUnmanaged(c);
         return NULL;
     }
     connect(c, SIGNAL(needsRepaint()), m_compositor, SLOT(scheduleRepaint()));
     addUnmanaged(c);
     emit unmanagedAdded(c);
     return c;
 }
 
 void Workspace::addClient(Client* c)
 {
     Group* grp = findGroup(c->window());
 
     emit clientAdded(c);
 
     if (grp != NULL)
         grp->gotLeader(c);
 
     if (c->isDesktop()) {
         desktops.append(c);
         if (active_client == NULL && should_get_focus.isEmpty() && c->isOnCurrentDesktop())
             requestFocus(c);   // TODO: Make sure desktop is active after startup if there's no other window active
     } else {
         FocusChain::self()->update(c, FocusChain::Update);
         clients.append(c);
         m_allClients.append(c);
     }
     if (!unconstrained_stacking_order.contains(c))
         unconstrained_stacking_order.append(c);   // Raise if it hasn't got any stacking position yet
     if (!stacking_order.contains(c))    // It'll be updated later, and updateToolWindows() requires
         stacking_order.append(c);      // c to be in stacking_order
     markXStackingOrderAsDirty();
     updateClientArea(); // This cannot be in manage(), because the client got added only now
     updateClientLayer(c);
     if (c->isDesktop()) {
         raiseClient(c);
         // If there's no active client, make this desktop the active one
         if (activeClient() == NULL && should_get_focus.count() == 0)
             activateClient(findDesktop(true, VirtualDesktopManager::self()->current()));
     }
     c->checkActiveModal();
     checkTransients(c->window());   // SELI TODO: Does this really belong here?
     updateStackingOrder(true);   // Propagate new client
     if (c->isUtility() || c->isMenu() || c->isToolbar())
         updateToolWindows(true);
 #ifdef KWIN_BUILD_TABBOX
     if (TabBox::TabBox::self()->isDisplayed())
         TabBox::TabBox::self()->reset(true);
 #endif
 }
 
 void Workspace::addUnmanaged(Unmanaged* c)
 {
     unmanaged.append(c);
     markXStackingOrderAsDirty();
 }
 
 /**
  * Destroys the client \a c
  */
 void Workspace::removeClient(Client* c)
 {
     if (c == active_popup_client)
         closeActivePopup();
     if (m_userActionsMenu->isMenuClient(c)) {
         m_userActionsMenu->close();
     }
 
     c->untab(QRect(), true);
 
     if (client_keys_client == c)
         setupWindowShortcutDone(false);
     if (!c->shortcut().isEmpty()) {
         c->setShortcut(QString());   // Remove from client_keys
         clientShortcutUpdated(c);   // Needed, since this is otherwise delayed by setShortcut() and wouldn't run
     }
 
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox->isDisplayed() && tabBox->currentClient() == c)
         tabBox->nextPrev(true);
 #endif
 
     Q_ASSERT(clients.contains(c) || desktops.contains(c));
     // TODO: if marked client is removed, notify the marked list
     clients.removeAll(c);
     m_allClients.removeAll(c);
     desktops.removeAll(c);
     markXStackingOrderAsDirty();
     attention_chain.removeAll(c);
     Group* group = findGroup(c->window());
     if (group != NULL)
         group->lostLeader();
 
     if (c == most_recently_raised)
         most_recently_raised = 0;
     should_get_focus.removeAll(c);
     Q_ASSERT(c != active_client);
     if (c == last_active_client)
         last_active_client = 0;
     if (c == delayfocus_client)
         cancelDelayFocus();
 
     emit clientRemoved(c);
 
     updateStackingOrder(true);
 
 #ifdef KWIN_BUILD_TABBOX
     if (tabBox->isDisplayed())
         tabBox->reset(true);
 #endif
 
     updateClientArea();
 }
 
 void Workspace::removeUnmanaged(Unmanaged* c)
 {
     assert(unmanaged.contains(c));
     unmanaged.removeAll(c);
     emit unmanagedRemoved(c);
     markXStackingOrderAsDirty();
 }
 
 void Workspace::addDeleted(Deleted* c, Toplevel *orig)
 {
     assert(!deleted.contains(c));
     deleted.append(c);
     const int unconstraintedIndex = unconstrained_stacking_order.indexOf(orig);
     if (unconstraintedIndex != -1) {
         unconstrained_stacking_order.replace(unconstraintedIndex, c);
     } else {
         unconstrained_stacking_order.append(c);
     }
     const int index = stacking_order.indexOf(orig);
     if (index != -1) {
         stacking_order.replace(index, c);
     } else {
         stacking_order.append(c);
     }
     markXStackingOrderAsDirty();
     connect(c, SIGNAL(needsRepaint()), m_compositor, SLOT(scheduleRepaint()));
 }
 
 void Workspace::removeDeleted(Deleted* c)
 {
     assert(deleted.contains(c));
     emit deletedRemoved(c);
     deleted.removeAll(c);
     unconstrained_stacking_order.removeAll(c);
     stacking_order.removeAll(c);
     markXStackingOrderAsDirty();
     if (c->wasClient() && m_compositor) {
         m_compositor->updateCompositeBlocking();
     }
 }
 
 void Workspace::updateToolWindows(bool also_hide)
 {
     // TODO: What if Client's transiency/group changes? should this be called too? (I'm paranoid, am I not?)
     if (!options->isHideUtilityWindowsForInactive()) {
         for (ClientList::ConstIterator it = clients.constBegin(); it != clients.constEnd(); ++it)
             if (!(*it)->tabGroup() || (*it)->tabGroup()->current() == *it)
                 (*it)->hideClient(false);
         return;
     }
     const Group* group = NULL;
     const Client* client = dynamic_cast<Client*>(active_client);
     // Go up in transiency hiearchy, if the top is found, only tool transients for the top mainwindow
     // will be shown; if a group transient is group, all tools in the group will be shown
     while (client != NULL) {
         if (!client->isTransient())
             break;
         if (client->groupTransient()) {
             group = client->group();
             break;
         }
         client = dynamic_cast<const Client*>(client->transientFor());
     }
     // Use stacking order only to reduce flicker, it doesn't matter if block_stacking_updates == 0,
     // I.e. if it's not up to date
 
     // SELI TODO: But maybe it should - what if a new client has been added that's not in stacking order yet?
     ClientList to_show, to_hide;
     for (ToplevelList::ConstIterator it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         Client *c = qobject_cast<Client*>(*it);
         if (!c) {
             continue;
         }
         if (c->isUtility() || c->isMenu() || c->isToolbar()) {
             bool show = true;
             if (!c->isTransient()) {
                 if (c->group()->members().count() == 1)   // Has its own group, keep always visible
                     show = true;
                 else if (client != NULL && c->group() == client->group())
                     show = true;
                 else
                     show = false;
             } else {
                 if (group != NULL && c->group() == group)
                     show = true;
                 else if (client != NULL && client->hasTransient(c, true))
                     show = true;
                 else
                     show = false;
             }
             if (!show && also_hide) {
                 const auto mainclients = c->mainClients();
                 // Don't hide utility windows which are standalone(?) or
                 // have e.g. kicker as mainwindow
                 if (mainclients.isEmpty())
                     show = true;
                 for (auto it2 = mainclients.constBegin();
                         it2 != mainclients.constEnd();
                         ++it2) {
                     if ((*it2)->isSpecialWindow())
                         show = true;
                 }
                 if (!show)
                     to_hide.append(c);
             }
             if (show)
                 to_show.append(c);
         }
     } // First show new ones, then hide
     for (int i = to_show.size() - 1;
             i >= 0;
             --i)  // From topmost
         // TODO: Since this is in stacking order, the order of taskbar entries changes :(
         to_show.at(i)->hideClient(false);
     if (also_hide) {
         for (ClientList::ConstIterator it = to_hide.constBegin();
                 it != to_hide.constEnd();
                 ++it)  // From bottommost
             (*it)->hideClient(true);
         updateToolWindowsTimer.stop();
     } else // setActiveClient() is after called with NULL client, quickly followed
         // by setting a new client, which would result in flickering
         resetUpdateToolWindowsTimer();
 }
 
 
 void Workspace::resetUpdateToolWindowsTimer()
 {
     updateToolWindowsTimer.start(200);
 }
 
 void Workspace::slotUpdateToolWindows()
 {
     updateToolWindows(true);
 }
 
 void Workspace::slotReloadConfig()
 {
     reconfigure();
 }
 
 void Workspace::reconfigure()
 {
     reconfigureTimer.start(200);
 }
 
 /**
  * Reread settings
  */
 
 void Workspace::slotReconfigure()
 {
     qCDebug(KWIN_CORE) << "Workspace::slotReconfigure()";
     reconfigureTimer.stop();
 
     bool borderlessMaximizedWindows = options->borderlessMaximizedWindows();
 
     kwinApp()->config()->reparseConfiguration();
     options->updateSettings();
 
     emit configChanged();
     m_userActionsMenu->discard();
     updateToolWindows(true);
 
     RuleBook::self()->load();
     for (auto it = m_allClients.begin();
             it != m_allClients.end();
             ++it) {
         (*it)->setupWindowRules(true);
         (*it)->applyWindowRules();
         RuleBook::self()->discardUsed(*it, false);
     }
 
     if (borderlessMaximizedWindows != options->borderlessMaximizedWindows() &&
             !options->borderlessMaximizedWindows()) {
         // in case borderless maximized windows option changed and new option
         // is to have borders, we need to unset the borders for all maximized windows
         for (auto it = m_allClients.begin();
                 it != m_allClients.end();
                 ++it) {
             if ((*it)->maximizeMode() == MaximizeFull)
                 (*it)->checkNoBorder();
         }
     }
 }
 
 void Workspace::slotCurrentDesktopChanged(uint oldDesktop, uint newDesktop)
 {
     closeActivePopup();
     ++block_focus;
     StackingUpdatesBlocker blocker(this);
     updateClientVisibilityOnDesktopChange(newDesktop);
     // Restore the focus on this desktop
     --block_focus;
 
     activateClientOnNewDesktop(newDesktop);
     emit currentDesktopChanged(oldDesktop, movingClient);
 }
 
 void Workspace::updateClientVisibilityOnDesktopChange(uint newDesktop)
 {
     for (ToplevelList::ConstIterator it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         Client *c = qobject_cast<Client*>(*it);
         if (!c) {
             continue;
         }
         if (!c->isOnDesktop(newDesktop) && c != movingClient && c->isOnCurrentActivity()) {
             (c)->updateVisibility();
         }
     }
     // Now propagate the change, after hiding, before showing
     if (rootInfo()) {
         rootInfo()->setCurrentDesktop(VirtualDesktopManager::self()->current());
     }
 
     if (movingClient && !movingClient->isOnDesktop(newDesktop)) {
         movingClient->setDesktop(newDesktop);
     }
 
     for (int i = stacking_order.size() - 1; i >= 0 ; --i) {
         Client *c = qobject_cast<Client*>(stacking_order.at(i));
         if (!c) {
             continue;
         }
         if (c->isOnDesktop(newDesktop) && c->isOnCurrentActivity())
             c->updateVisibility();
     }
     if (showingDesktop())   // Do this only after desktop change to avoid flicker
         setShowingDesktop(false);
 }
 
 void Workspace::activateClientOnNewDesktop(uint desktop)
 {
     AbstractClient* c = NULL;
     if (options->focusPolicyIsReasonable()) {
         c = findClientToActivateOnDesktop(desktop);
     }
     // If "unreasonable focus policy" and active_client is on_all_desktops and
     // under mouse (Hence == old_active_client), conserve focus.
     // (Thanks to Volker Schatz <V.Schatz at thphys.uni-heidelberg.de>)
     else if (active_client && active_client->isShown(true) && active_client->isOnCurrentDesktop())
         c = active_client;
 
     if (c == NULL && !desktops.isEmpty())
         c = findDesktop(true, desktop);
 
     if (c != active_client)
         setActiveClient(NULL);
 
     if (c)
         requestFocus(c);
     else if (!desktops.isEmpty())
         requestFocus(findDesktop(true, desktop));
     else
         focusToNull();
 }
 
 AbstractClient *Workspace::findClientToActivateOnDesktop(uint desktop)
 {
     if (movingClient != NULL && active_client == movingClient &&
         FocusChain::self()->contains(active_client, desktop) &&
         active_client->isShown(true) && active_client->isOnCurrentDesktop()) {
         // A requestFocus call will fail, as the client is already active
         return active_client;
     }
     // from actiavtion.cpp
     if (options->isNextFocusPrefersMouse()) {
         ToplevelList::const_iterator it = stackingOrder().constEnd();
         while (it != stackingOrder().constBegin()) {
             Client *client = qobject_cast<Client*>(*(--it));
             if (!client) {
                 continue;
             }
 
             if (!(client->isShown(false) && client->isOnDesktop(desktop) &&
                 client->isOnCurrentActivity() && client->isOnActiveScreen()))
                 continue;
 
             if (client->geometry().contains(Cursor::pos())) {
                 if (!client->isDesktop())
                     return client;
             break; // unconditional break  - we do not pass the focus to some client below an unusable one
             }
         }
     }
     return FocusChain::self()->getForActivation(desktop);
 }
 
 /**
  * Updates the current activity when it changes
  * do *not* call this directly; it does not set the activity.
  *
  * Shows/Hides windows according to the stacking order
  */
 
 void Workspace::updateCurrentActivity(const QString &new_activity)
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return;
     }
     //closeActivePopup();
     ++block_focus;
     // TODO: Q_ASSERT( block_stacking_updates == 0 ); // Make sure stacking_order is up to date
     StackingUpdatesBlocker blocker(this);
 
     // Optimized Desktop switching: unmapping done from back to front
     // mapping done from front to back => less exposure events
     //Notify::raise((Notify::Event) (Notify::DesktopChange+new_desktop));
 
     for (ToplevelList::ConstIterator it = stacking_order.constBegin();
             it != stacking_order.constEnd();
             ++it) {
         Client *c = qobject_cast<Client*>(*it);
         if (!c) {
             continue;
         }
         if (!c->isOnActivity(new_activity) && c != movingClient && c->isOnCurrentDesktop()) {
             c->updateVisibility();
         }
     }
 
     // Now propagate the change, after hiding, before showing
     //rootInfo->setCurrentDesktop( currentDesktop() );
 
     /* TODO someday enable dragging windows to other activities
     if ( movingClient && !movingClient->isOnDesktop( new_desktop ))
         {
         movingClient->setDesktop( new_desktop );
         */
 
     for (int i = stacking_order.size() - 1; i >= 0 ; --i) {
         Client *c = qobject_cast<Client*>(stacking_order.at(i));
         if (!c) {
             continue;
         }
         if (c->isOnActivity(new_activity))
             c->updateVisibility();
     }
 
     //FIXME not sure if I should do this either
     if (showingDesktop())   // Do this only after desktop change to avoid flicker
         setShowingDesktop(false);
 
     // Restore the focus on this desktop
     --block_focus;
     AbstractClient* c = 0;
 
     //FIXME below here is a lot of focuschain stuff, probably all wrong now
     if (options->focusPolicyIsReasonable()) {
         // Search in focus chain
         c = FocusChain::self()->getForActivation(VirtualDesktopManager::self()->current());
     }
     // If "unreasonable focus policy" and active_client is on_all_desktops and
     // under mouse (Hence == old_active_client), conserve focus.
     // (Thanks to Volker Schatz <V.Schatz at thphys.uni-heidelberg.de>)
     else if (active_client && active_client->isShown(true) && active_client->isOnCurrentDesktop() && active_client->isOnCurrentActivity())
         c = active_client;
 
     if (c == NULL && !desktops.isEmpty())
         c = findDesktop(true, VirtualDesktopManager::self()->current());
 
     if (c != active_client)
         setActiveClient(NULL);
 
     if (c)
         requestFocus(c);
     else if (!desktops.isEmpty())
         requestFocus(findDesktop(true, VirtualDesktopManager::self()->current()));
     else
         focusToNull();
 
     // Not for the very first time, only if something changed and there are more than 1 desktops
 
     //if ( effects != NULL && old_desktop != 0 && old_desktop != new_desktop )
     //    static_cast<EffectsHandlerImpl*>( effects )->desktopChanged( old_desktop );
     if (compositing() && m_compositor)
         m_compositor->addRepaintFull();
 #else
     Q_UNUSED(new_activity)
 #endif
 }
 
 void Workspace::slotDesktopCountChanged(uint previousCount, uint newCount)
 {
     Q_UNUSED(previousCount)
     Placement::self()->reinitCascading(0);
 
     resetClientAreas(newCount);
 }
 
 void Workspace::resetClientAreas(uint desktopCount)
 {
     // Make it +1, so that it can be accessed as [1..numberofdesktops]
     workarea.clear();
     workarea.resize(desktopCount + 1);
     restrictedmovearea.clear();
     restrictedmovearea.resize(desktopCount + 1);
     screenarea.clear();
 
     updateClientArea(true);
 }
 
 void Workspace::selectWmInputEventMask()
 {
     uint32_t presentMask = 0;
     Xcb::WindowAttributes attr(rootWindow());
     if (!attr.isNull()) {
         presentMask = attr->your_event_mask;
     }
 
     Xcb::selectInput(rootWindow(),
                      presentMask |
                      XCB_EVENT_MASK_KEY_PRESS |
                      XCB_EVENT_MASK_PROPERTY_CHANGE |
                      XCB_EVENT_MASK_COLOR_MAP_CHANGE |
                      XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
                      XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                      XCB_EVENT_MASK_FOCUS_CHANGE | // For NotifyDetailNone
                      XCB_EVENT_MASK_EXPOSURE
     );
 }
 
 /**
  * Sends client \a c to desktop \a desk.
  *
  * Takes care of transients as well.
  */
 void Workspace::sendClientToDesktop(AbstractClient* c, int desk, bool dont_activate)
 {
     if ((desk < 1 && desk != NET::OnAllDesktops) || desk > static_cast<int>(VirtualDesktopManager::self()->count()))
         return;
     int old_desktop = c->desktop();
     bool was_on_desktop = c->isOnDesktop(desk) || c->isOnAllDesktops();
     c->setDesktop(desk);
     if (c->desktop() != desk)   // No change or desktop forced
         return;
     desk = c->desktop(); // Client did range checking
 
     if (c->isOnDesktop(VirtualDesktopManager::self()->current())) {
         if (c->wantsTabFocus() && options->focusPolicyIsReasonable() &&
                 !was_on_desktop && // for stickyness changes
                 !dont_activate)
             requestFocus(c);
         else
             restackClientUnderActive(c);
     } else
         raiseClient(c);
 
     c->checkWorkspacePosition( QRect(), old_desktop );
 
     auto transients_stacking_order = ensureStackingOrder(c->transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it)
         sendClientToDesktop(*it, desk, dont_activate);
     updateClientArea();
 }
 
 /**
  * checks whether the X Window with the input focus is on our X11 screen
  * if the window cannot be determined or inspected, resturn depends on whether there's actually
  * more than one screen
  *
  * this is NOT in any way related to XRandR multiscreen
  *
  */
 extern bool is_multihead; // main.cpp
 bool Workspace::isOnCurrentHead()
 {
     if (!is_multihead) {
         return true;
     }
 
     Xcb::CurrentInput currentInput;
     if (currentInput.window() == XCB_WINDOW_NONE) {
         return !is_multihead;
     }
 
     Xcb::WindowGeometry geometry(currentInput.window());
     if (geometry.isNull()) { // should not happen
         return !is_multihead;
     }
 
     return rootWindow() == geometry->root;
 }
 
 void Workspace::sendClientToScreen(AbstractClient* c, int screen)
 {
     c->sendToScreen(screen);
 }
 
 void Workspace::sendPingToWindow(xcb_window_t window, xcb_timestamp_t timestamp)
 {
     if (rootInfo()) {
         rootInfo()->sendPing(window, timestamp);
     }
 }
 
 /**
  * Delayed focus functions
  */
 void Workspace::delayFocus()
 {
     requestFocus(delayfocus_client);
     cancelDelayFocus();
 }
 
 void Workspace::requestDelayFocus(AbstractClient* c)
 {
     delayfocus_client = c;
     delete delayFocusTimer;
     delayFocusTimer = new QTimer(this);
     connect(delayFocusTimer, SIGNAL(timeout()), this, SLOT(delayFocus()));
     delayFocusTimer->setSingleShot(true);
     delayFocusTimer->start(options->delayFocusInterval());
 }
 
 void Workspace::cancelDelayFocus()
 {
     delete delayFocusTimer;
     delayFocusTimer = 0;
 }
 
 bool Workspace::checkStartupNotification(xcb_window_t w, KStartupInfoId &id, KStartupInfoData &data)
 {
     return startup->checkStartup(w, id, data) == KStartupInfo::Match;
 }
 
 /**
  * Puts the focus on a dummy window
  * Just using XSetInputFocus() with None would block keyboard input
  */
 void Workspace::focusToNull()
 {
     if (m_nullFocus) {
         m_nullFocus->focus();
     }
 }
 
 void Workspace::setShowingDesktop(bool showing)
 {
     const bool changed = showing != showing_desktop;
     if (rootInfo() && changed) {
         rootInfo()->setShowingDesktop(showing);
     }
     showing_desktop = showing;
 
     AbstractClient *topDesk = nullptr;
 
     { // for the blocker RAII
     StackingUpdatesBlocker blocker(this); // updateLayer & lowerClient would invalidate stacking_order
     for (int i = stacking_order.count() - 1; i > -1; --i) {
         AbstractClient *c = qobject_cast<AbstractClient*>(stacking_order.at(i));
         if (c && c->isOnCurrentDesktop()) {
             if (c->isDock()) {
                 c->updateLayer();
             } else if (c->isDesktop() && c->isShown(true)) {
                 c->updateLayer();
                 lowerClient(c);
                 if (!topDesk)
                     topDesk = c;
                 if (Client *client = qobject_cast<Client*>(c)) {
                     foreach (Client *cm, client->group()->members()) {
                         cm->updateLayer();
                     }
                 }
             }
         }
     }
     } // ~StackingUpdatesBlocker
 
     if (showing_desktop && topDesk) {
         requestFocus(topDesk);
     } else if (!showing_desktop && changed) {
         const auto client = FocusChain::self()->getForActivation(VirtualDesktopManager::self()->current());
         if (client) {
             activateClient(client);
         }
     }
     if (changed)
         emit showingDesktopChanged(showing);
 }
 
 void Workspace::disableGlobalShortcutsForClient(bool disable)
 {
     if (global_shortcuts_disabled_for_client == disable)
         return;
     QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.kde.kglobalaccel"),
                                                           QStringLiteral("/kglobalaccel"),
                                                           QStringLiteral("org.kde.KGlobalAccel"),
                                                           QStringLiteral("blockGlobalShortcuts"));
     message.setArguments(QList<QVariant>() << disable);
     QDBusConnection::sessionBus().asyncCall(message);
 
     global_shortcuts_disabled_for_client = disable;
     // Update also Alt+LMB actions etc.
     for (ClientList::ConstIterator it = clients.constBegin();
             it != clients.constEnd();
             ++it)
         (*it)->updateMouseGrab();
 }
 
 QString Workspace::supportInformation() const
 {
     QString support;
     const QString yes = QStringLiteral("yes\n");
     const QString no = QStringLiteral("no\n");
 
     support.append(ki18nc("Introductory text shown in the support information.",
         "KWin Support Information:\n"
         "The following information should be used when requesting support on e.g. https://forum.kde.org.\n"
         "It provides information about the currently running instance, which options are used,\n"
         "what OpenGL driver and which effects are running.\n"
         "Please post the information provided underneath this introductory text to a paste bin service\n"
         "like http://paste.kde.org instead of pasting into support threads.\n").toString());
     support.append(QStringLiteral("\n==========================\n\n"));
     // all following strings are intended for support. They need to be pasted to e.g forums.kde.org
     // it is expected that the support will happen in English language or that the people providing
     // help understand English. Because of that all texts are not translated
     support.append(QStringLiteral("Version\n"));
     support.append(QStringLiteral("=======\n"));
     support.append(QStringLiteral("KWin version: "));
     support.append(QStringLiteral(KWIN_VERSION_STRING));
     support.append(QStringLiteral("\n"));
     support.append(QStringLiteral("Qt Version: "));
     support.append(QString::fromUtf8(qVersion()));
     support.append(QStringLiteral("\n"));
     support.append(QStringLiteral("Qt compile version: %1\n").arg(QStringLiteral(QT_VERSION_STR)));
     support.append(QStringLiteral("XCB compile version: %1\n\n").arg(QStringLiteral(XCB_VERSION_STRING)));
     support.append(QStringLiteral("Operation Mode: "));
     switch (kwinApp()->operationMode()) {
     case Application::OperationModeX11:
         support.append(QStringLiteral("X11 only"));
         break;
     case Application::OperationModeWaylandOnly:
         support.append(QStringLiteral("Wayland Only"));
         break;
     case Application::OperationModeXwayland:
         support.append(QStringLiteral("Xwayland"));
         break;
     }
     support.append(QStringLiteral("\n\n"));
 
     support.append(QStringLiteral("Build Options\n"));
     support.append(QStringLiteral("=============\n"));
 
     support.append(QStringLiteral("KWIN_BUILD_DECORATIONS: "));
 #ifdef KWIN_BUILD_DECORATIONS
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("KWIN_BUILD_TABBOX: "));
 #ifdef KWIN_BUILD_TABBOX
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("KWIN_BUILD_ACTIVITIES: "));
 #ifdef KWIN_BUILD_ACTIVITIES
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_DRM: "));
 #if HAVE_DRM
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_GBM: "));
 #if HAVE_GBM
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_X11_XCB: "));
 #if HAVE_X11_XCB
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_EPOXY_GLX: "));
 #if HAVE_EPOXY_GLX
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("HAVE_WAYLAND_EGL: "));
 #if HAVE_WAYLAND_EGL
     support.append(yes);
 #else
     support.append(no);
 #endif
     support.append(QStringLiteral("\n"));
 
     if (auto c = kwinApp()->x11Connection()) {
         support.append(QStringLiteral("X11\n"));
         support.append(QStringLiteral("===\n"));
         auto x11setup = xcb_get_setup(c);
         support.append(QStringLiteral("Vendor: %1\n").arg(QString::fromUtf8(QByteArray::fromRawData(xcb_setup_vendor(x11setup), xcb_setup_vendor_length(x11setup)))));
         support.append(QStringLiteral("Vendor Release: %1\n").arg(x11setup->release_number));
         support.append(QStringLiteral("Protocol Version/Revision: %1/%2\n").arg(x11setup->protocol_major_version).arg(x11setup->protocol_minor_version));
         const auto extensions = Xcb::Extensions::self()->extensions();
         for (const auto &e : extensions) {
             support.append(QStringLiteral("%1: %2; Version: 0x%3\n").arg(QString::fromUtf8(e.name))
                                                                     .arg(e.present ? yes.trimmed() : no.trimmed())
                                                                     .arg(QString::number(e.version, 16)));
         }
         support.append(QStringLiteral("\n"));
     }
 
     if (auto bridge = Decoration::DecorationBridge::self()) {
         support.append(QStringLiteral("Decoration\n"));
         support.append(QStringLiteral("==========\n"));
         support.append(bridge->supportInformation());
         support.append(QStringLiteral("\n"));
     }
     support.append(QStringLiteral("Platform\n"));
     support.append(QStringLiteral("==========\n"));
     support.append(kwinApp()->platform()->supportInformation());
     support.append(QStringLiteral("\n"));
 
     support.append(QStringLiteral("Options\n"));
     support.append(QStringLiteral("=======\n"));
     const QMetaObject *metaOptions = options->metaObject();
     auto printProperty = [] (const QVariant &variant) {
         if (variant.type() == QVariant::Size) {
             const QSize &s = variant.toSize();
             return QStringLiteral("%1x%2").arg(QString::number(s.width())).arg(QString::number(s.height()));
         }
         if (QLatin1String(variant.typeName()) == QLatin1String("KWin::OpenGLPlatformInterface") ||
                 QLatin1String(variant.typeName()) == QLatin1String("KWin::Options::WindowOperation")) {
             return QString::number(variant.toInt());
         }
         return variant.toString();
     };
     for (int i=0; i<metaOptions->propertyCount(); ++i) {
         const QMetaProperty property = metaOptions->property(i);
         if (QLatin1String(property.name()) == QLatin1String("objectName")) {
             continue;
         }
         support.append(QStringLiteral("%1: %2\n").arg(property.name()).arg(printProperty(options->property(property.name()))));
     }
     support.append(QStringLiteral("\nScreen Edges\n"));
     support.append(QStringLiteral(  "============\n"));
     const QMetaObject *metaScreenEdges = ScreenEdges::self()->metaObject();
     for (int i=0; i<metaScreenEdges->propertyCount(); ++i) {
         const QMetaProperty property = metaScreenEdges->property(i);
         if (QLatin1String(property.name()) == QLatin1String("objectName")) {
             continue;
         }
         support.append(QStringLiteral("%1: %2\n").arg(property.name()).arg(printProperty(ScreenEdges::self()->property(property.name()))));
     }
     support.append(QStringLiteral("\nScreens\n"));
     support.append(QStringLiteral(  "=======\n"));
     support.append(QStringLiteral("Multi-Head: "));
     if (is_multihead) {
         support.append(QStringLiteral("yes\n"));
         support.append(QStringLiteral("Head: %1\n").arg(screen_number));
     } else {
         support.append(QStringLiteral("no\n"));
     }
     support.append(QStringLiteral("Active screen follows mouse: "));
     if (screens()->isCurrentFollowsMouse())
         support.append(QStringLiteral(" yes\n"));
     else
         support.append(QStringLiteral(" no\n"));
     support.append(QStringLiteral("Number of Screens: %1\n\n").arg(screens()->count()));
     for (int i=0; i<screens()->count(); ++i) {
         const QRect geo = screens()->geometry(i);
         support.append(QStringLiteral("Screen %1:\n").arg(i));
         support.append(QStringLiteral("---------\n"));
         support.append(QStringLiteral("Name: %1\n").arg(screens()->name(i)));
         support.append(QStringLiteral("Geometry: %1,%2,%3x%4\n")
                               .arg(geo.x())
                               .arg(geo.y())
                               .arg(geo.width())
                               .arg(geo.height()));
         support.append(QStringLiteral("Scale: %1\n").arg(screens()->scale(i)));
         support.append(QStringLiteral("Refresh Rate: %1\n\n").arg(screens()->refreshRate(i)));
     }
     support.append(QStringLiteral("\nCompositing\n"));
     support.append(QStringLiteral(  "===========\n"));
     if (effects) {
         support.append(QStringLiteral("Compositing is active\n"));
         switch (effects->compositingType()) {
         case OpenGL2Compositing:
         case OpenGLCompositing: {
             GLPlatform *platform = GLPlatform::instance();
             if (platform->isGLES()) {
                 support.append(QStringLiteral("Compositing Type: OpenGL ES 2.0\n"));
             } else {
                 support.append(QStringLiteral("Compositing Type: OpenGL\n"));
             }
             support.append(QStringLiteral("OpenGL vendor string: ") +   QString::fromUtf8(platform->glVendorString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL renderer string: ") + QString::fromUtf8(platform->glRendererString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL version string: ") +  QString::fromUtf8(platform->glVersionString()) + QStringLiteral("\n"));
             support.append(QStringLiteral("OpenGL platform interface: "));
             switch (platform->platformInterface()) {
             case GlxPlatformInterface:
                 support.append(QStringLiteral("GLX"));
                 break;
             case EglPlatformInterface:
                 support.append(QStringLiteral("EGL"));
                 break;
             default:
                 support.append(QStringLiteral("UNKNOWN"));
             }
             support.append(QStringLiteral("\n"));
 
             if (platform->supports(LimitedGLSL) || platform->supports(GLSL))
                 support.append(QStringLiteral("OpenGL shading language version string: ") + QString::fromUtf8(platform->glShadingLanguageVersionString()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("Driver: ") + GLPlatform::driverToString(platform->driver()) + QStringLiteral("\n"));
             if (!platform->isMesaDriver())
                 support.append(QStringLiteral("Driver version: ") + GLPlatform::versionToString(platform->driverVersion()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("GPU class: ") + GLPlatform::chipClassToString(platform->chipClass()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("OpenGL version: ") + GLPlatform::versionToString(platform->glVersion()) + QStringLiteral("\n"));
 
             if (platform->supports(LimitedGLSL) || platform->supports(GLSL))
                 support.append(QStringLiteral("GLSL version: ") + GLPlatform::versionToString(platform->glslVersion()) + QStringLiteral("\n"));
 
             if (platform->isMesaDriver())
                 support.append(QStringLiteral("Mesa version: ") + GLPlatform::versionToString(platform->mesaVersion()) + QStringLiteral("\n"));
             if (platform->serverVersion() > 0)
                 support.append(QStringLiteral("X server version: ") + GLPlatform::versionToString(platform->serverVersion()) + QStringLiteral("\n"));
             if (platform->kernelVersion() > 0)
                 support.append(QStringLiteral("Linux kernel version: ") + GLPlatform::versionToString(platform->kernelVersion()) + QStringLiteral("\n"));
 
             support.append(QStringLiteral("Direct rendering: "));
             support.append(QStringLiteral("Requires strict binding: "));
             if (!platform->isLooseBinding()) {
                 support.append(QStringLiteral("yes\n"));
             } else {
                 support.append(QStringLiteral("no\n"));
             }
             support.append(QStringLiteral("GLSL shaders: "));
             if (platform->supports(GLSL)) {
                 if (platform->supports(LimitedGLSL)) {
                     support.append(QStringLiteral(" limited\n"));
                 } else {
                     support.append(QStringLiteral(" yes\n"));
                 }
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
             support.append(QStringLiteral("Texture NPOT support: "));
             if (platform->supports(TextureNPOT)) {
                 if (platform->supports(LimitedNPOT)) {
                     support.append(QStringLiteral(" limited\n"));
                 } else {
                     support.append(QStringLiteral(" yes\n"));
                 }
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
             support.append(QStringLiteral("Virtual Machine: "));
             if (platform->isVirtualMachine()) {
                 support.append(QStringLiteral(" yes\n"));
             } else {
                 support.append(QStringLiteral(" no\n"));
             }
 
             support.append(QStringLiteral("OpenGL 2 Shaders are used\n"));
             support.append(QStringLiteral("Painting blocks for vertical retrace: "));
             if (m_compositor->scene()->blocksForRetrace())
                 support.append(QStringLiteral(" yes\n"));
             else
                 support.append(QStringLiteral(" no\n"));
             break;
         }
         case XRenderCompositing:
             support.append(QStringLiteral("Compositing Type: XRender\n"));
             break;
         case QPainterCompositing:
             support.append("Compositing Type: QPainter\n");
             break;
         case NoCompositing:
         default:
             support.append(QStringLiteral("Something is really broken, neither OpenGL nor XRender is used"));
         }
         support.append(QStringLiteral("\nLoaded Effects:\n"));
         support.append(QStringLiteral(  "---------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->loadedEffects()) {
             support.append(effect + QStringLiteral("\n"));
         }
         support.append(QStringLiteral("\nCurrently Active Effects:\n"));
         support.append(QStringLiteral(  "-------------------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->activeEffects()) {
             support.append(effect + QStringLiteral("\n"));
         }
         support.append(QStringLiteral("\nEffect Settings:\n"));
         support.append(QStringLiteral(  "----------------\n"));
         foreach (const QString &effect, static_cast<EffectsHandlerImpl*>(effects)->loadedEffects()) {
             support.append(static_cast<EffectsHandlerImpl*>(effects)->supportInformation(effect));
             support.append(QStringLiteral("\n"));
         }
     } else {
         support.append(QStringLiteral("Compositing is not active\n"));
     }
     return support;
 }
 
 Client *Workspace::findClient(std::function<bool (const Client*)> func) const
 {
     if (Client *ret = Toplevel::findInList(clients, func)) {
         return ret;
     }
     if (Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     return nullptr;
 }
 
 AbstractClient *Workspace::findAbstractClient(std::function<bool (const AbstractClient*)> func) const
 {
     if (AbstractClient *ret = Toplevel::findInList(m_allClients, func)) {
         return ret;
     }
     if (Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     if (waylandServer()) {
         if (AbstractClient *ret = Toplevel::findInList(waylandServer()->internalClients(), func)) {
             return ret;
         }
     }
     return nullptr;
 }
 
 Unmanaged *Workspace::findUnmanaged(std::function<bool (const Unmanaged*)> func) const
 {
     return Toplevel::findInList(unmanaged, func);
 }
 
 Unmanaged *Workspace::findUnmanaged(xcb_window_t w) const
 {
     return findUnmanaged([w](const Unmanaged *u) {
         return u->window() == w;
     });
 }
 
 Client *Workspace::findClient(Predicate predicate, xcb_window_t w) const
 {
     switch (predicate) {
     case Predicate::WindowMatch:
         return findClient([w](const Client *c) {
             return c->window() == w;
         });
     case Predicate::WrapperIdMatch:
         return findClient([w](const Client *c) {
             return c->wrapperId() == w;
         });
     case Predicate::FrameIdMatch:
         return findClient([w](const Client *c) {
             return c->frameId() == w;
         });
     case Predicate::InputIdMatch:
         return findClient([w](const Client *c) {
             return c->inputId() == w;
         });
     }
     return nullptr;
 }
 
 Toplevel *Workspace::findToplevel(std::function<bool (const Toplevel*)> func) const
 {
     if (Client *ret = Toplevel::findInList(clients, func)) {
         return ret;
     }
     if (Client *ret = Toplevel::findInList(desktops, func)) {
         return ret;
     }
     if (Unmanaged *ret = Toplevel::findInList(unmanaged, func)) {
         return ret;
     }
     return nullptr;
 }
 
 Toplevel *Workspace::findToplevel(QWindow *w) const
 {
     if (!w) {
         return nullptr;
     }
     if (waylandServer()) {
         if (auto c = waylandServer()->findClient(w)) {
             return c;
         }
     }
     return findUnmanaged(w->winId());
 }
 
 bool Workspace::hasClient(const AbstractClient *c)
 {
     if (auto cc = dynamic_cast<const Client*>(c)) {
         return hasClient(cc);
     } else {
         return findAbstractClient([c](const AbstractClient *test) {
             return test == c;
         }) != nullptr;
     }
     return false;
 }
 
 void Workspace::forEachAbstractClient(std::function< void (AbstractClient*) > func)
 {
     std::for_each(m_allClients.constBegin(), m_allClients.constEnd(), func);
     std::for_each(desktops.constBegin(), desktops.constEnd(), func);
 }
 
 Toplevel *Workspace::findInternal(QWindow *w) const
 {
     if (!w) {
         return nullptr;
     }
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         return findUnmanaged(w->winId());
     } else {
         return waylandServer()->findClient(w);
     }
 }
 
 void Workspace::markXStackingOrderAsDirty()
 {
     m_xStackingDirty = true;
     if (kwinApp()->x11Connection()) {
         m_xStackingQueryTree.reset(new Xcb::Tree(kwinApp()->x11RootWindow()));
     }
 }
 
 void Workspace::setWasUserInteraction()
 {
     if (was_user_interaction) {
         return;
     }
     was_user_interaction = true;
     // might be called from within the filter, so delay till we now the filter returned
     QTimer::singleShot(0, this,
         [this] {
             m_wasUserInteractionFilter.reset();
         }
     );
 }
 
 } // namespace