diff --git a/CMakeLists.txt b/CMakeLists.txt
index c5bca4d6f..2f8e31a2e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,676 +1,677 @@
 project(KWIN)
 set(PROJECT_VERSION "5.10.90")
 set(PROJECT_VERSION_MAJOR 5)
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 set(QT_MIN_VERSION "5.7.0")
 set(KF5_MIN_VERSION "5.34.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH} )
 
 find_package(ECM 0.0.11 REQUIRED NO_MODULE)
 
 include(FeatureSummary)
 include(WriteBasicConfigVersionFile)
 include(GenerateExportHeader)
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
     Concurrent
     Core
     DBus
     Quick
     QuickWidgets
     Script
     UiTools
     Widgets
     X11Extras
 )
 
 find_package(Qt5Test ${QT_MIN_VERSION} CONFIG QUIET)
 set_package_properties(Qt5Test PROPERTIES
          PURPOSE "Required for tests"
          TYPE OPTIONAL
          )
 add_feature_info("Qt5Test" Qt5Test_FOUND "Required for building tests")
 if (NOT Qt5Test_FOUND)
     set(BUILD_TESTING OFF CACHE BOOL "Build the testing tree.")
 endif()
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 
 include(ECMInstallIcons)
 include(ECMOptionalAddSubdirectory)
 
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_USE_QSTRINGBUILDER)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-inconsistent-missing-override")
 endif()
 
 find_package(Qt5Multimedia QUIET)
 set_package_properties(Qt5Multimedia PROPERTIES
          PURPOSE "Runtime-only dependency for effect video playback"
          TYPE RUNTIME
          )
 
 
 # required frameworks by Core
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Config
     ConfigWidgets
     CoreAddons
     Crash
     GlobalAccel
     I18n
     Init
     Notifications
     Package
     Plasma
     WidgetsAddons
     WindowSystem
     IconThemes
     IdleTime
     Wayland
 )
 # required frameworks by config modules
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Completion
     Declarative
     KCMUtils
     KIO
     TextWidgets
     NewStuff
     Service
     XmlGui
 )
 
 find_package(Threads)
 set_package_properties(Threads PROPERTIES
          PURPOSE "Needed for VirtualTerminal support in KWin Wayland"
          TYPE REQUIRED
          )
 
 # optional frameworks
 find_package(KF5Activities ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Activities PROPERTIES
          PURPOSE "Enable building of KWin with kactivities support"
          TYPE OPTIONAL
          )
 add_feature_info("KF5Activities" KF5Activities_FOUND "Enable building of KWin with kactivities support")
 
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5DocTools PROPERTIES
          PURPOSE "Enable building documentation"
          TYPE OPTIONAL
          )
 add_feature_info("KF5DocTools" KF5DocTools_FOUND "Enable building documentation")
 
 find_package(KDecoration2 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "For screenlocker integration in kwin_wayland")
 
 find_package(Breeze 5.9.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
                        TYPE OPTIONAL
                        PURPOSE "For setting the default window decoration plugin")
 if(${Breeze_FOUND})
     if(${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 add_feature_info("Breeze-Decoration" HAVE_BREEZE_DECO "Default decoration plugin Breeze")
 
 find_package(EGL)
 set_package_properties(EGL PROPERTIES
                        TYPE RUNTIME
                        PURPOSE "Required to build KWin with EGL support"
                       )
 
 find_package(epoxy)
 set_package_properties(epoxy PROPERTIES DESCRIPTION "libepoxy"
                        URL "http://github.com/anholt/libepoxy"
                        TYPE REQUIRED
                        PURPOSE "OpenGL dispatch library"
                       )
 
 set(HAVE_DL_LIBRARY FALSE)
 if(epoxy_HAS_GLX)
     find_library(DL_LIBRARY dl)
     if(DL_LIBRARY)
         set(HAVE_DL_LIBRARY TRUE)
     endif()
 endif()
 
 find_package(Wayland 1.2 REQUIRED COMPONENTS Cursor OPTIONAL_COMPONENTS Egl)
 set_package_properties(Wayland PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 add_feature_info("Wayland::EGL" Wayland_Egl_FOUND "Enable building of Wayland backend and QPA with EGL support.")
 set(HAVE_WAYLAND_EGL FALSE)
 if(Wayland_Egl_FOUND)
     set(HAVE_WAYLAND_EGL TRUE)
 endif()
 
 find_package(XKB 0.7.0)
 set_package_properties(XKB PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 
 find_package(Libinput 1.5)
 set_package_properties(Libinput PROPERTIES TYPE OPTIONAL PURPOSE "Required for input handling on Wayland.")
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES  URL "http://www.freedesktop.org/software/systemd/libudev/"
                                         DESCRIPTION "Linux device library."
                                         TYPE OPTIONAL
                                         PURPOSE "Required for input handling on Wayland."
                         )
 set(HAVE_INPUT FALSE)
 if (Libinput_FOUND AND UDEV_FOUND)
     set(HAVE_INPUT TRUE)
 endif()
 set(HAVE_UDEV FALSE)
 if (UDEV_FOUND)
     set(HAVE_UDEV TRUE)
 endif()
 
 find_package(Libdrm 2.4.62)
 set_package_properties(Libdrm PROPERTIES TYPE OPTIONAL PURPOSE "Required for drm output on Wayland.")
 set(HAVE_DRM FALSE)
 if(Libdrm_FOUND AND UDEV_FOUND)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl ouput of drm backend.")
 set(HAVE_GBM FALSE)
 if(HAVE_DRM AND gbm_FOUND)
     set(HAVE_GBM TRUE)
 endif()
 
 find_package(libhybris)
 set_package_properties(libhybris PROPERTIES TYPE OPTIONAL PURPOSE "Required for libhybris backend")
 set(HAVE_LIBHYBRIS ${libhybris_FOUND})
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES DESCRIPTION "X11 libraries"
                         URL "http://www.x.org"
                         TYPE REQUIRED
                     )
 add_feature_info("XInput" X11_Xinput_FOUND "Required for poll-free mouse cursor updates")
 set(HAVE_X11_XINPUT ${X11_Xinput_FOUND})
 
 # All the required XCB components
 find_package(XCB 1.10
     REQUIRED COMPONENTS
         XCB
         XFIXES
         DAMAGE
         COMPOSITE
         SHAPE
         SYNC
         RENDER
         RANDR
         KEYSYMS
         IMAGE
         SHM
         GLX
         CURSOR
     OPTIONAL_COMPONENTS
         ICCCM
 )
 set_package_properties(XCB PROPERTIES TYPE REQUIRED)
 
 # and the optional XCB dependencies
 if (XCB_ICCCM_VERSION VERSION_LESS "0.4")
     set(XCB_ICCCM_FOUND FALSE)
 endif()
 add_feature_info("XCB-ICCCM" XCB_ICCCM_FOUND "Required for building test applications for KWin")
 
 find_package(X11_XCB)
 set_package_properties(X11_XCB PROPERTIES
                        PURPOSE "Required for building X11 windowed backend of kwin_wayland"
                        TYPE OPTIONAL)
 
 # dependencies for QPA plugin
 if(Qt5Core_VERSION VERSION_LESS "5.8.0")
     find_package(Qt5PlatformSupport REQUIRED)
 else()
     find_package(Qt5FontDatabaseSupport REQUIRED)
     find_package(Qt5ThemeSupport REQUIRED)
     find_package(Qt5EventDispatcherSupport REQUIRED)
 endif()
 
 find_package(Freetype REQUIRED)
 set_package_properties(Freetype PROPERTIES DESCRIPTION "A font rendering engine"
                        URL "http://www.freetype.org"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 find_package(Fontconfig REQUIRED)
 set_package_properties(Fontconfig PROPERTIES DESCRIPTION "Font access configuration library"
                        URL "http://www.freedesktop.org/wiki/Software/fontconfig"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 
 find_package(Xwayland)
 set_package_properties(Xwayland PROPERTIES
     URL "http://x.org"
     DESCRIPTION "Xwayland X server"
     TYPE RUNTIME
     PURPOSE "Needed for running kwin_wayland"
     )
 
 ########### configure tests ###############
 include(CMakeDependentOption)
 
 option(KWIN_BUILD_DECORATIONS "Enable building of KWin decorations." ON)
 option(KWIN_BUILD_KCMS "Enable building of KWin configuration modules." ON)
 option(KWIN_BUILD_TABBOX "Enable building of KWin Tabbox functionality" ON)
 option(KWIN_BUILD_XRENDER_COMPOSITING "Enable building of KWin with XRender Compositing support" ON)
 cmake_dependent_option(KWIN_BUILD_ACTIVITIES "Enable building of KWin with kactivities support" ON "KF5Activities_FOUND" OFF)
 
 # Binary name of KWin
 set(KWIN_NAME "kwin")
 set(KWIN_INTERNAL_NAME_X11 "kwin_x11")
 set(KWIN_INTERNAL_NAME_WAYLAND "kwin_wayland")
 set(KWIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 # KWIN_HAVE_XRENDER_COMPOSITING - whether XRender-based compositing support is available: may be disabled
 if( KWIN_BUILD_XRENDER_COMPOSITING )
     set( KWIN_HAVE_XRENDER_COMPOSITING 1 )
 endif()
 
 include_directories(${XKB_INCLUDE_DIR})
 
 include_directories(${epoxy_INCLUDE_DIR})
 set(HAVE_EPOXY_GLX ${epoxy_HAS_GLX})
 
 # for things that are also used by kwin libraries
 configure_file(libkwineffects/kwinconfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects/kwinconfig.h )
 # for kwin internal things
 set(HAVE_X11_XCB ${X11_XCB_FOUND})
 
 include(CheckIncludeFile)
 include(CheckIncludeFiles)
 include(CheckSymbolExists)
 check_include_files(unistd.h HAVE_UNISTD_H)
 check_include_files(malloc.h HAVE_MALLOC_H)
 
 check_include_file("sys/prctl.h" HAVE_SYS_PRCTL_H)
 check_symbol_exists(PR_SET_DUMPABLE "sys/prctl.h" HAVE_PR_SET_DUMPABLE)
 check_symbol_exists(PR_SET_PDEATHSIG "sys/prctl.h" HAVE_PR_SET_PDEATHSIG)
 check_include_file("sys/procctl.h" HAVE_SYS_PROCCTL_H)
 check_symbol_exists(PROC_TRACE_CTL "sys/procctl.h" HAVE_PROC_TRACE_CTL)
 if (HAVE_PR_SET_DUMPABLE OR HAVE_PROC_TRACE_CTL)
     set(CAN_DISABLE_PTRACE TRUE)
 endif()
 add_feature_info("prctl/procctl tracing control"
                  CAN_DISABLE_PTRACE
                  "Required for disallowing ptrace on kwin_wayland process")
 
 check_include_file("sys/sysmacros.h" HAVE_SYS_SYSMACROS_H)
 configure_file(config-kwin.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kwin.h )
 
 check_include_file("linux/vt.h" HAVE_LINUX_VT_H)
 add_feature_info("linux/vt.h"
                  HAVE_LINUX_VT_H
                  "Required for virtual terminal support under wayland")
 check_include_file("linux/fb.h"    HAVE_LINUX_FB_H)
 add_feature_info("linux/fb.h"
                  HAVE_LINUX_FB_H
                  "Required for the fbdev backend")
 
 ########### global ###############
 set(kwin_effects_dbus_xml ${CMAKE_CURRENT_SOURCE_DIR}/org.kde.kwin.Effects.xml)
 
 include_directories(BEFORE
     ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/libkwineffects
     ${CMAKE_CURRENT_SOURCE_DIR}/effects
     ${CMAKE_CURRENT_SOURCE_DIR}/tabbox
     )
 
 add_subdirectory( libkwineffects )
 if(KWIN_BUILD_KCMS)
     add_subdirectory( kcmkwin )
 endif()
 
 add_subdirectory( data )
 
 add_subdirectory( effects )
 add_subdirectory( scripts )
 add_subdirectory( tabbox )
 add_subdirectory(scripting)
 add_subdirectory(helpers)
 
 ########### next target ###############
 
 set(kwin_KDEINIT_SRCS
    workspace.cpp
    dbusinterface.cpp
    abstract_client.cpp
    client.cpp
    client_machine.cpp
    cursor.cpp
    debug_console.cpp
    tabgroup.cpp
    focuschain.cpp
    globalshortcuts.cpp
    input.cpp
    input_event.cpp
    input_event_spy.cpp
    keyboard_input.cpp
    keyboard_layout.cpp
    keyboard_layout_switching.cpp
    keyboard_repeat.cpp
    pointer_input.cpp
    touch_input.cpp
    netinfo.cpp
    placement.cpp
    atoms.cpp
    utils.cpp
    layers.cpp
    main.cpp
    options.cpp
    outline.cpp
    events.cpp
    killwindow.cpp
    geometrytip.cpp
    screens.cpp
    shadow.cpp
    sm.cpp
    group.cpp
    manage.cpp
    overlaywindow.cpp
    activation.cpp
    useractions.cpp
    geometry.cpp
    rules.cpp
    composite.cpp
    toplevel.cpp
    unmanaged.cpp
    scene.cpp
    scene_xrender.cpp
    scene_opengl.cpp
    scene_qpainter.cpp
    screenlockerwatcher.cpp
    thumbnailitem.cpp
    lanczosfilter.cpp
    deleted.cpp
    effects.cpp
    effectloader.cpp
    virtualdesktops.cpp
    xcbutils.cpp
    x11eventfilter.cpp
    logind.cpp
    onscreennotification.cpp
    osd.cpp
     screenedge.cpp
     scripting/scripting.cpp
     scripting/workspace_wrapper.cpp
     scripting/meta.cpp
     scripting/scriptedeffect.cpp
     scripting/scriptingutils.cpp
     scripting/timer.cpp
     scripting/scripting_model.cpp
     scripting/dbuscall.cpp
     scripting/screenedgeitem.cpp
     scripting/scripting_logging.cpp
     decorations/decoratedclient.cpp
     decorations/decorationbridge.cpp
     decorations/decorationpalette.cpp
     decorations/settings.cpp
     decorations/decorationrenderer.cpp
     decorations/decorations_logging.cpp
     abstract_egl_backend.cpp
     platform.cpp
     shell_client.cpp
     wayland_server.cpp
     wayland_cursor_theme.cpp
     virtualkeyboard.cpp
     appmenu.cpp
     modifier_only_shortcuts.cpp
     xkb.cpp
     gestures.cpp
     popup_input_filter.cpp
     abstract_opengl_context_attribute_builder.cpp
     egl_context_attribute_builder.cpp
+    was_user_interaction_x11_filter.cpp
    )
 
 if(KWIN_BUILD_TABBOX)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         tabbox/tabbox.cpp
         tabbox/clientmodel.cpp
         tabbox/desktopchain.cpp
         tabbox/desktopmodel.cpp
         tabbox/switcheritem.cpp
         tabbox/tabboxconfig.cpp
         tabbox/tabboxhandler.cpp
         tabbox/tabbox_logging.cpp
   )
 endif()
 
 if(KWIN_BUILD_ACTIVITIES)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         activities.cpp
     )
 endif()
 
 if(UDEV_FOUND)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         udev.cpp
     )
 endif()
 
 if(HAVE_INPUT)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         libinput/context.cpp
         libinput/connection.cpp
         libinput/device.cpp
         libinput/events.cpp
         libinput/libinput_logging.cpp
     )
     if (HAVE_LINUX_VT_H)
          set(kwin_KDEINIT_SRCS
              ${kwin_KDEINIT_SRCS}
              virtual_terminal.cpp
          )
     endif()
 endif()
 
 kconfig_add_kcfg_files(kwin_KDEINIT_SRCS settings.kcfgc)
 
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl )
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/org.freedesktop.ScreenSaver.xml screenlocker_interface)
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS org.kde.kappmenu.xml appmenu_interface )
 
 qt5_add_resources( kwin_KDEINIT_SRCS resources.qrc )
 
 ki18n_wrap_ui(kwin_KDEINIT_SRCS
     debug_console.ui
     shortcutdialog.ui
 )
 
 ########### target link libraries ###############
 
 set(kwin_OWN_LIBS
     kwineffects
     kwinxrenderutils
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Script
     Qt5::X11Extras
 )
 
 set(kwin_KDE_LIBS
     KF5::ConfigCore
     KF5::CoreAddons
     KF5::ConfigWidgets
     KF5::GlobalAccel
     KF5::GlobalAccelPrivate
     KF5::I18n
     KF5::Notifications
     KF5::Package
     KF5::Plasma
     KF5::WindowSystem
     KDecoration2::KDecoration
     KDecoration2::KDecoration2Private
     PW::KScreenLocker
 )
 
 set(kwin_XLIB_LIBS
     ${X11_X11_LIB}
     ${X11_ICE_LIB}
     ${X11_SM_LIB}
 )
 
 set(kwin_XCB_LIBS
     XCB::XCB
     XCB::XFIXES
     XCB::DAMAGE
     XCB::COMPOSITE
     XCB::SHAPE
     XCB::SYNC
     XCB::RENDER
     XCB::RANDR
     XCB::KEYSYMS
     XCB::SHM
     XCB::GLX
 )
 
 set(kwin_WAYLAND_LIBS
     XKB::XKB
     KF5::WaylandClient
     KF5::WaylandServer
     Wayland::Cursor
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
 if(KWIN_BUILD_ACTIVITIES)
     set(kwin_KDE_LIBS ${kwin_KDE_LIBS} KF5::Activities)
 endif()
 
 set(kwinLibs
     ${kwin_OWN_LIBS}
     ${kwin_QT_LIBS}
     ${kwin_KDE_LIBS}
     ${kwin_XLIB_LIBS}
     ${kwin_XCB_LIBS}
     ${kwin_WAYLAND_LIBS}
 )
 
 if(UDEV_FOUND)
     set(kwinLibs ${kwinLibs} ${UDEV_LIBS})
 endif()
 
 if(HAVE_INPUT)
     set(kwinLibs ${kwinLibs} Libinput::Libinput)
 endif()
 
 add_library(kwin SHARED ${kwin_KDEINIT_SRCS})
 
 set_target_properties(kwin PROPERTIES
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
    )
 
 target_link_libraries(kwin ${kwinLibs})
 generate_export_header(kwin EXPORT_FILE_NAME kwin_export.h)
 
 target_link_libraries(kwin kwinglutils ${epoxy_LIBRARY})
 
 kf5_add_kdeinit_executable(kwin_x11 main_x11.cpp)
 target_link_libraries(kdeinit_kwin_x11 kwin KF5::Crash)
 
 install(TARGETS kwin             ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP )
 install(TARGETS kdeinit_kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 install(TARGETS kwin_x11         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_executable(kwin_wayland main_wayland.cpp)
 target_link_libraries(kwin_wayland kwin)
 
 install(TARGETS kwin_wayland         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install( FILES kwin.kcfg  DESTINATION  ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg )
 install( FILES kwin.notifyrc  DESTINATION  ${KNOTIFYRC_INSTALL_DIR} RENAME ${KWIN_NAME}.notifyrc)
 install(
     FILES
         org.kde.KWin.xml
         org.kde.kwin.Compositing.xml
         org.kde.kwin.Effects.xml
     DESTINATION
         ${KDE_INSTALL_DBUSINTERFACEDIR}
 )
 install( FILES ${CMAKE_CURRENT_BINARY_DIR}/kwin_export.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
 
 # Install the KWin/Script service type
 install( FILES scripting/kwinscript.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
 
 ecm_install_icons(
     ICONS
         16-apps-kwin.png
         32-apps-kwin.png
         48-apps-kwin.png
         sc-apps-kwin.svgz
     DESTINATION
         ${ICON_INSTALL_DIR}
     THEME
         hicolor
 )
 
 add_subdirectory(qml)
 add_subdirectory(autotests)
 add_subdirectory(tests)
 add_subdirectory(packageplugins)
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(ECMPackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 ecm_configure_package_config_file(KWinDBusInterfaceConfig.cmake.in
     "${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake"
     PATH_VARS KDE_INSTALL_DBUSINTERFACEDIR
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake
     DESTINATION ${CMAKECONFIG_INSTALL_DIR})
diff --git a/events.cpp b/events.cpp
index d93214612..74c0d155d 100644
--- a/events.cpp
+++ b/events.cpp
@@ -1,1516 +1,1510 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
 
  This file contains things relevant to handling incoming events.
 
 */
 
 #include "client.h"
 #include "cursor.h"
 #include "focuschain.h"
 #include "netinfo.h"
 #include "workspace.h"
 #include "atoms.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "group.h"
 #include "rules.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "effects.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "xcbutils.h"
 
 #include <KDecoration2/Decoration>
 
 #include <QApplication>
 #include <QDebug>
 #include <QHoverEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QStyleHints>
 #include <QWhatsThis>
 #include <QWheelEvent>
 
 #include <kkeyserver.h>
 
 #include <xcb/sync.h>
 #ifdef XCB_ICCCM_FOUND
 #include <xcb/xcb_icccm.h>
 #endif
 
 #include "composite.h"
 #include "x11eventfilter.h"
 
 #include "wayland_server.h"
 #include <KWayland/Server/surface_interface.h>
 
 #ifndef XCB_GE_GENERIC
 #define XCB_GE_GENERIC 35
 typedef struct xcb_ge_generic_event_t {
     uint8_t  response_type; /**<  */
     uint8_t  extension; /**<  */
     uint16_t sequence; /**<  */
     uint32_t length; /**<  */
     uint16_t event_type; /**<  */
     uint8_t  pad0[22]; /**<  */
     uint32_t full_sequence; /**<  */
 } xcb_ge_generic_event_t;
 #endif
 
 namespace KWin
 {
 
 extern int currentRefreshRate();
 
 // ****************************************
 // Workspace
 // ****************************************
 
 static xcb_window_t findEventWindow(xcb_generic_event_t *event)
 {
     const uint8_t eventType = event->response_type & ~0x80;
     switch(eventType) {
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE:
         return reinterpret_cast<xcb_key_press_event_t*>(event)->event;
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         return reinterpret_cast<xcb_button_press_event_t*>(event)->event;
     case XCB_MOTION_NOTIFY:
         return reinterpret_cast<xcb_motion_notify_event_t*>(event)->event;
     case XCB_ENTER_NOTIFY:
     case XCB_LEAVE_NOTIFY:
         return reinterpret_cast<xcb_enter_notify_event_t*>(event)->event;
     case XCB_FOCUS_IN:
     case XCB_FOCUS_OUT:
         return reinterpret_cast<xcb_focus_in_event_t*>(event)->event;
     case XCB_EXPOSE:
         return reinterpret_cast<xcb_expose_event_t*>(event)->window;
     case XCB_GRAPHICS_EXPOSURE:
         return reinterpret_cast<xcb_graphics_exposure_event_t*>(event)->drawable;
     case XCB_NO_EXPOSURE:
         return reinterpret_cast<xcb_no_exposure_event_t*>(event)->drawable;
     case XCB_VISIBILITY_NOTIFY:
         return reinterpret_cast<xcb_visibility_notify_event_t*>(event)->window;
     case XCB_CREATE_NOTIFY:
         return reinterpret_cast<xcb_create_notify_event_t*>(event)->window;
     case XCB_DESTROY_NOTIFY:
         return reinterpret_cast<xcb_destroy_notify_event_t*>(event)->window;
     case XCB_UNMAP_NOTIFY:
         return reinterpret_cast<xcb_unmap_notify_event_t*>(event)->window;
     case XCB_MAP_NOTIFY:
         return reinterpret_cast<xcb_map_notify_event_t*>(event)->window;
     case XCB_MAP_REQUEST:
         return reinterpret_cast<xcb_map_request_event_t*>(event)->window;
     case XCB_REPARENT_NOTIFY:
         return reinterpret_cast<xcb_reparent_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_NOTIFY:
         return reinterpret_cast<xcb_configure_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_REQUEST:
         return reinterpret_cast<xcb_configure_request_event_t*>(event)->window;
     case XCB_GRAVITY_NOTIFY:
         return reinterpret_cast<xcb_gravity_notify_event_t*>(event)->window;
     case XCB_RESIZE_REQUEST:
         return reinterpret_cast<xcb_resize_request_event_t*>(event)->window;
     case XCB_CIRCULATE_NOTIFY:
     case XCB_CIRCULATE_REQUEST:
         return reinterpret_cast<xcb_circulate_notify_event_t*>(event)->window;
     case XCB_PROPERTY_NOTIFY:
         return reinterpret_cast<xcb_property_notify_event_t*>(event)->window;
     case XCB_COLORMAP_NOTIFY:
         return reinterpret_cast<xcb_colormap_notify_event_t*>(event)->window;
     case XCB_CLIENT_MESSAGE:
         return reinterpret_cast<xcb_client_message_event_t*>(event)->window;
     default:
         // extension handling
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             return reinterpret_cast<xcb_shape_notify_event_t*>(event)->affected_window;
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent()) {
             return reinterpret_cast<xcb_damage_notify_event_t*>(event)->drawable;
         }
         return XCB_WINDOW_NONE;
     }
 }
 
 QVector<QByteArray> s_xcbEerrors({
     QByteArrayLiteral("Success"),
     QByteArrayLiteral("BadRequest"),
     QByteArrayLiteral("BadValue"),
     QByteArrayLiteral("BadWindow"),
     QByteArrayLiteral("BadPixmap"),
     QByteArrayLiteral("BadAtom"),
     QByteArrayLiteral("BadCursor"),
     QByteArrayLiteral("BadFont"),
     QByteArrayLiteral("BadMatch"),
     QByteArrayLiteral("BadDrawable"),
     QByteArrayLiteral("BadAccess"),
     QByteArrayLiteral("BadAlloc"),
     QByteArrayLiteral("BadColor"),
     QByteArrayLiteral("BadGC"),
     QByteArrayLiteral("BadIDChoice"),
     QByteArrayLiteral("BadName"),
     QByteArrayLiteral("BadLength"),
     QByteArrayLiteral("BadImplementation"),
     QByteArrayLiteral("Unknown")});
 
 
 void Workspace::registerEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.append(filter);
     else
         m_eventFilters.append(filter);
 }
 
 void Workspace::unregisterEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.removeOne(filter);
     else
         m_eventFilters.removeOne(filter);
 }
 
 
 /*!
   Handles workspace specific XCB event
  */
 bool Workspace::workspaceEvent(xcb_generic_event_t *e)
 {
     const uint8_t eventType = e->response_type & ~0x80;
     if (!eventType) {
         // let's check whether it's an error from one of the extensions KWin uses
         xcb_generic_error_t *error = reinterpret_cast<xcb_generic_error_t*>(e);
         const QVector<Xcb::ExtensionData> extensions = Xcb::Extensions::self()->extensions();
         for (const auto &extension : extensions) {
             if (error->major_code == extension.majorOpcode) {
                 QByteArray errorName;
                 if (error->error_code < s_xcbEerrors.size()) {
                     errorName = s_xcbEerrors.at(error->error_code);
                 } else if (error->error_code >= extension.errorBase) {
                     const int index = error->error_code - extension.errorBase;
                     if (index >= 0 && index < extension.errorCodes.size()) {
                         errorName = extension.errorCodes.at(index);
                     }
                 }
                 if (errorName.isEmpty()) {
                     errorName = QByteArrayLiteral("Unknown");
                 }
                 qCWarning(KWIN_CORE, "XCB error: %d (%s), sequence: %d, resource id: %d, major code: %d (%s), minor code: %d (%s)",
                          int(error->error_code), errorName.constData(),
                          int(error->sequence), int(error->resource_id),
                          int(error->major_code), extension.name.constData(),
                          int(error->minor_code),
                          extension.opCodes.size() > error->minor_code ? extension.opCodes.at(error->minor_code).constData() : "Unknown");
                 return true;
             }
         }
         return false;
     }
 
     if (eventType == XCB_GE_GENERIC) {
         xcb_ge_generic_event_t *ge = reinterpret_cast<xcb_ge_generic_event_t *>(e);
 
         foreach (X11EventFilter *filter, m_genericEventFilters) {
             if (filter->extension() == ge->extension && filter->genericEventTypes().contains(ge->event_type) && filter->event(e)) {
                 return true;
             }
         }
     } else {
         foreach (X11EventFilter *filter, m_eventFilters) {
             if (filter->eventTypes().contains(eventType) && filter->event(e)) {
                 return true;
             }
         }
     }
 
     if (effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()
             && (eventType == XCB_KEY_PRESS || eventType == XCB_KEY_RELEASE))
         return false; // let Qt process it, it'll be intercepted again in eventFilter()
 
     if (eventType == XCB_PROPERTY_NOTIFY || eventType == XCB_CLIENT_MESSAGE) {
         NET::Properties dirtyProtocols;
         NET::Properties2 dirtyProtocols2;
         rootInfo()->event(e, &dirtyProtocols, &dirtyProtocols2);
         if (dirtyProtocols & NET::DesktopNames)
             VirtualDesktopManager::self()->save();
         if (dirtyProtocols2 & NET::WM2DesktopLayout)
             VirtualDesktopManager::self()->updateLayout();
     }
 
     // events that should be handled before Clients can get them
     switch (eventType) {
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE: {
-        was_user_interaction = true;
         auto *mouseEvent = reinterpret_cast<xcb_button_press_event_t*>(e);
 #ifdef KWIN_BUILD_TABBOX
         if (TabBox::TabBox::self()->isGrabbed()) {
             return TabBox::TabBox::self()->handleMouseEvent(mouseEvent);
         }
 #endif
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(mouseEvent)) {
             return true;
         }
         break;
     }
     case XCB_MOTION_NOTIFY: {
         if (kwinApp()->operationMode() != Application::OperationModeX11) {
             // ignore X11 pointer events generated on X windows if we are not on X
             return true;
         }
         auto *mouseEvent = reinterpret_cast<xcb_motion_notify_event_t*>(e);
         const QPoint rootPos(mouseEvent->root_x, mouseEvent->root_y);
 #ifdef KWIN_BUILD_TABBOX
         if (TabBox::TabBox::self()->isGrabbed()) {
             ScreenEdges::self()->check(rootPos, QDateTime::fromMSecsSinceEpoch(xTime()), true);
             return TabBox::TabBox::self()->handleMouseEvent(mouseEvent);
         }
 #endif
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(mouseEvent)) {
             return true;
         }
         if (QWidget::mouseGrabber()) {
             ScreenEdges::self()->check(rootPos, QDateTime::fromMSecsSinceEpoch(xTime()), true);
         } else {
             ScreenEdges::self()->check(rootPos, QDateTime::fromMSecsSinceEpoch(mouseEvent->time));
         }
         break;
     }
     case XCB_KEY_PRESS: {
-        was_user_interaction = true;
         int keyQt;
         xcb_key_press_event_t *event = reinterpret_cast<xcb_key_press_event_t*>(e);
         KKeyServer::xcbKeyPressEventToQt(event, &keyQt);
 //            qDebug() << "Workspace::keyPress( " << keyQt << " )";
         if (Client *c = dynamic_cast<Client*>(movingClient)) {
             c->keyPressEvent(keyQt, event->time);
             return true;
         }
 #ifdef KWIN_BUILD_TABBOX
         if (TabBox::TabBox::self()->isGrabbed()) {
             TabBox::TabBox::self()->keyPress(keyQt);
             return true;
         }
 #endif
         break;
     }
     case XCB_KEY_RELEASE:
-        was_user_interaction = true;
 #ifdef KWIN_BUILD_TABBOX
         if (TabBox::TabBox::self()->isGrabbed()) {
             TabBox::TabBox::self()->keyRelease(reinterpret_cast<xcb_key_release_event_t*>(e));
             return true;
         }
 #endif
         break;
     case XCB_CONFIGURE_NOTIFY:
         if (reinterpret_cast<xcb_configure_notify_event_t*>(e)->event == rootWindow())
             markXStackingOrderAsDirty();
         break;
     };
 
     const xcb_window_t eventWindow = findEventWindow(e);
     if (eventWindow != XCB_WINDOW_NONE) {
         if (Client* c = findClient(Predicate::WindowMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Client* c = findClient(Predicate::WrapperIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Client* c = findClient(Predicate::FrameIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Client *c = findClient(Predicate::InputIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Unmanaged* c = findUnmanaged(eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else {
             // We want to pass root window property events to effects
             if (eventType == XCB_PROPERTY_NOTIFY) {
                 auto *event = reinterpret_cast<xcb_property_notify_event_t*>(e);
                 if (event->window == rootWindow()) {
                     emit propertyNotify(event->atom);
                 }
             }
         }
     }
     if (Client *c = dynamic_cast<Client*>(movingClient)) {
         if (eventType == XCB_BUTTON_PRESS || eventType == XCB_BUTTON_RELEASE || eventType == XCB_MOTION_NOTIFY) {
             if (c->moveResizeGrabWindow() == reinterpret_cast<xcb_button_press_event_t*>(e)->event && c->windowEvent(e)) {
                 return true;
             }
         }
     }
 
     switch (eventType) {
     case XCB_CREATE_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_create_notify_event_t*>(e);
         if (event->parent == rootWindow() &&
                 !QWidget::find(event->window) &&
                 !event->override_redirect) {
             // see comments for allowClientActivation()
             updateXTime();
             const xcb_timestamp_t t = xTime();
             xcb_change_property(connection(), XCB_PROP_MODE_REPLACE, event->window, atoms->kde_net_wm_user_creation_time, XCB_ATOM_CARDINAL, 32, 1, &t);
         }
         break;
     }
     case XCB_UNMAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_unmap_notify_event_t*>(e);
         return (event->event != event->window);   // hide wm typical event from Qt
     }
     case XCB_REPARENT_NOTIFY: {
         //do not confuse Qt with these events. After all, _we_ are the
         //window manager who does the reparenting.
         return true;
     }
     case XCB_DESTROY_NOTIFY: {
         return false;
     }
     case XCB_MAP_REQUEST: {
         updateXTime();
 
         const auto *event = reinterpret_cast<xcb_map_request_event_t*>(e);
         if (Client* c = findClient(Predicate::WindowMatch, event->window)) {
             // e->xmaprequest.window is different from e->xany.window
             // TODO this shouldn't be necessary now
             c->windowEvent(e);
             FocusChain::self()->update(c, FocusChain::Update);
         } else if ( true /*|| e->xmaprequest.parent != root */ ) {
             // NOTICE don't check for the parent being the root window, this breaks when some app unmaps
             // a window, changes something and immediately maps it back, without giving KWin
             // a chance to reparent it back to root
             // since KWin can get MapRequest only for root window children and
             // children of WindowWrapper (=clients), the check is AFAIK useless anyway
             // NOTICE: The save-set support in Client::mapRequestEvent() actually requires that
             // this code doesn't check the parent to be root.
             if (!createClient(event->window, false)) {
                 xcb_map_window(connection(), event->window);
                 const uint32_t values[] = { XCB_STACK_MODE_ABOVE };
                 xcb_configure_window(connection(), event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
             }
         }
         return true;
     }
     case XCB_MAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_map_notify_event_t*>(e);
         if (event->override_redirect) {
             Unmanaged* c = findUnmanaged(event->window);
             if (c == NULL)
                 c = createUnmanaged(event->window);
             if (c)
                 return c->windowEvent(e);
         }
         return (event->event != event->window);   // hide wm typical event from Qt
     }
 
     case XCB_ENTER_NOTIFY: {
         if (QWhatsThis::inWhatsThisMode()) {
             QWidget* w = QWidget::find(reinterpret_cast<xcb_enter_notify_event_t*>(e)->event);
             if (w)
                 QWhatsThis::leaveWhatsThisMode();
         }
         if (ScreenEdges::self()->isEntered(reinterpret_cast<xcb_enter_notify_event_t*>(e)))
             return true;
         break;
     }
     case XCB_LEAVE_NOTIFY: {
         if (!QWhatsThis::inWhatsThisMode())
             break;
         // TODO is this cliente ever found, given that client events are searched above?
         const auto *event = reinterpret_cast<xcb_leave_notify_event_t*>(e);
         Client* c = findClient(Predicate::FrameIdMatch, event->event);
         if (c && event->detail != XCB_NOTIFY_DETAIL_INFERIOR)
             QWhatsThis::leaveWhatsThisMode();
         break;
     }
     case XCB_CONFIGURE_REQUEST: {
         const auto *event = reinterpret_cast<xcb_configure_request_event_t*>(e);
         if (event->parent == rootWindow()) {
             uint32_t values[5] = { 0, 0, 0, 0, 0};
             const uint32_t value_mask = event->value_mask
                                         & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH);
             int i = 0;
             if (value_mask & XCB_CONFIG_WINDOW_X) {
                 values[i++] = event->x;
             }
             if (value_mask & XCB_CONFIG_WINDOW_Y) {
                 values[i++] = event->y;
             }
             if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
                 values[i++] = event->width;
             }
             if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
                 values[i++] = event->height;
             }
             if (value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
                 values[i++] = event->border_width;
             }
             xcb_configure_window(connection(), event->window, value_mask, values);
             return true;
         }
         break;
     }
     case XCB_FOCUS_IN: {
         const auto *event = reinterpret_cast<xcb_focus_in_event_t*>(e);
         if (event->event == rootWindow()
                 && (event->detail == XCB_NOTIFY_DETAIL_NONE || event->detail == XCB_NOTIFY_DETAIL_POINTER_ROOT || event->detail == XCB_NOTIFY_DETAIL_INFERIOR)) {
             Xcb::CurrentInput currentInput;
             updateXTime(); // focusToNull() uses xTime(), which is old now (FocusIn has no timestamp)
             // it seems we can "loose" focus reversions when the closing client hold a grab
             // => catch the typical pattern (though we don't want the focus on the root anyway) #348935
             const bool lostFocusPointerToRoot = currentInput->focus == rootWindow() && event->detail == XCB_NOTIFY_DETAIL_INFERIOR;
             if (!currentInput.isNull() && (currentInput->focus == XCB_WINDOW_NONE || currentInput->focus == XCB_INPUT_FOCUS_POINTER_ROOT || lostFocusPointerToRoot)) {
                 //kWarning( 1212 ) << "X focus set to None/PointerRoot, reseting focus" ;
                 AbstractClient *c = mostRecentlyActivatedClient();
                 if (c != NULL)
                     requestFocus(c, true);
                 else if (activateNextClient(NULL))
                     ; // ok, activated
                 else
                     focusToNull();
             }
         }
     }
         // fall through
     case XCB_FOCUS_OUT:
         return true; // always eat these, they would tell Qt that KWin is the active app
     case XCB_CLIENT_MESSAGE:
         if (ScreenEdges::self()->isEntered(reinterpret_cast<xcb_client_message_event_t*>(e)))
             return true;
         break;
     default:
         if (eventType == Xcb::Extensions::self()->randrNotifyEvent() && Xcb::Extensions::self()->isRandrAvailable()) {
             auto *event = reinterpret_cast<xcb_randr_screen_change_notify_event_t*>(e);
             xcb_screen_t *screen = defaultScreen();
             if (event->rotation & (XCB_RANDR_ROTATION_ROTATE_90 | XCB_RANDR_ROTATION_ROTATE_270)) {
                 screen->width_in_pixels = event->height;
                 screen->height_in_pixels = event->width;
                 screen->width_in_millimeters = event->mheight;
                 screen->height_in_millimeters = event->mwidth;
             } else {
                 screen->width_in_pixels = event->width;
                 screen->height_in_pixels = event->height;
                 screen->width_in_millimeters = event->mwidth;
                 screen->height_in_millimeters = event->mheight;
             }
             if (compositing()) {
                 // desktopResized() should take care of when the size or
                 // shape of the desktop has changed, but we also want to
                 // catch refresh rate changes
                 if (m_compositor->xrrRefreshRate() != currentRefreshRate())
                     m_compositor->setCompositeResetTimer(0);
             }
 
         } else if (eventType == Xcb::Extensions::self()->syncAlarmNotifyEvent() && Xcb::Extensions::self()->isSyncAvailable()) {
             for (Client *c : clients)
                 c->syncEvent(reinterpret_cast< xcb_sync_alarm_notify_event_t* >(e));
             for (Client *c : desktops)
                 c->syncEvent(reinterpret_cast< xcb_sync_alarm_notify_event_t* >(e));
         } else if (eventType == Xcb::Extensions::self()->fixesCursorNotifyEvent() && Xcb::Extensions::self()->isFixesAvailable()) {
             Cursor::self()->notifyCursorChanged(reinterpret_cast<xcb_xfixes_cursor_notify_event_t*>(e)->cursor_serial);
         }
         break;
     }
     return false;
 }
 
 // Used only to filter events that need to be processed by Qt first
 // (e.g. keyboard input to be composed), otherwise events are
 // handle by the XEvent filter above
 bool Workspace::workspaceEvent(QEvent* e)
 {
     if ((e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease || e->type() == QEvent::ShortcutOverride)
             && effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(static_cast< QKeyEvent* >(e));
         return true;
     }
     return false;
 }
 
 // ****************************************
 // Client
 // ****************************************
 
 /*!
   General handler for XEvents concerning the client window
  */
 bool Client::windowEvent(xcb_generic_event_t *e)
 {
     if (findEventWindow(e) == window()) { // avoid doing stuff on frame or wrapper
         NET::Properties dirtyProperties;
         NET::Properties2 dirtyProperties2;
         double old_opacity = opacity();
         info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
 
         if ((dirtyProperties & NET::WMName) != 0)
             fetchName();
         if ((dirtyProperties & NET::WMIconName) != 0)
             fetchIconicName();
         if ((dirtyProperties & NET::WMStrut) != 0
                 || (dirtyProperties2 & NET::WM2ExtendedStrut) != 0) {
             workspace()->updateClientArea();
         }
         if ((dirtyProperties & NET::WMIcon) != 0)
             getIcons();
         // Note there's a difference between userTime() and info->userTime()
         // info->userTime() is the value of the property, userTime() also includes
         // updates of the time done by KWin (ButtonPress on windowrapper etc.).
         if ((dirtyProperties2 & NET::WM2UserTime) != 0) {
             workspace()->setWasUserInteraction();
             updateUserTime(info->userTime());
         }
         if ((dirtyProperties2 & NET::WM2StartupId) != 0)
             startupIdChanged();
         if (dirtyProperties2 & NET::WM2Opacity) {
             if (compositing()) {
                 addRepaintFull();
                 emit opacityChanged(this, old_opacity);
             } else {
                 // forward to the frame if there's possibly another compositing manager running
                 NETWinInfo i(connection(), frameId(), rootWindow(), 0, 0);
                 i.setOpacity(info->opacity());
             }
         }
         if (dirtyProperties2 & NET::WM2FrameOverlap) {
             // ### Inform the decoration
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
             emit windowRoleChanged();
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
             getResourceClass();
         }
         if (dirtyProperties2.testFlag(NET::WM2BlockCompositing)) {
             setBlockingCompositing(info->isBlockingCompositing());
         }
         if (dirtyProperties2.testFlag(NET::WM2GroupLeader)) {
             checkGroup();
             updateAllowedActions(); // Group affects isMinimizable()
         }
         if (dirtyProperties2.testFlag(NET::WM2Urgency)) {
             updateUrgency();
         }
         if (dirtyProperties2 & NET::WM2OpaqueRegion) {
             getWmOpaqueRegion();
         }
         if (dirtyProperties2 & NET::WM2DesktopFileName) {
             setDesktopFileName(QByteArray(info->desktopFileName()));
         }
     }
 
     const uint8_t eventType = e->response_type & ~0x80;
     switch(eventType) {
     case XCB_UNMAP_NOTIFY:
         unmapNotifyEvent(reinterpret_cast<xcb_unmap_notify_event_t*>(e));
         break;
     case XCB_DESTROY_NOTIFY:
         destroyNotifyEvent(reinterpret_cast<xcb_destroy_notify_event_t*>(e));
         break;
     case XCB_MAP_REQUEST:
         // this one may pass the event to workspace
         return mapRequestEvent(reinterpret_cast<xcb_map_request_event_t*>(e));
     case XCB_CONFIGURE_REQUEST:
         configureRequestEvent(reinterpret_cast<xcb_configure_request_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_KEY_PRESS:
         updateUserTime(reinterpret_cast<xcb_key_press_event_t*>(e)->time);
-        workspace()->setWasUserInteraction();
         break;
     case XCB_BUTTON_PRESS: {
         const auto *event = reinterpret_cast<xcb_button_press_event_t*>(e);
         updateUserTime(event->time);
-        workspace()->setWasUserInteraction();
         buttonPressEvent(event->event, event->detail, event->state,
                          event->event_x, event->event_y, event->root_x, event->root_y, event->time);
         break;
     }
     case XCB_KEY_RELEASE:
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         break;
     case XCB_BUTTON_RELEASE: {
         const auto *event = reinterpret_cast<xcb_button_release_event_t*>(e);
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         buttonReleaseEvent(event->event, event->detail, event->state,
                            event->event_x, event->event_y, event->root_x, event->root_y);
         break;
     }
     case XCB_MOTION_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_motion_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_ENTER_NOTIFY: {
         auto *event = reinterpret_cast<xcb_enter_notify_event_t*>(e);
         enterNotifyEvent(event);
         // MotionNotify is guaranteed to be generated only if the mouse
         // move start and ends in the window; for cases when it only
         // starts or only ends there, Enter/LeaveNotify are generated.
         // Fake a MotionEvent in such cases to make handle of mouse
         // events simpler (Qt does that too).
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_LEAVE_NOTIFY: {
         auto *event = reinterpret_cast<xcb_leave_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         leaveNotifyEvent(event);
         // not here, it'd break following enter notify handling
         // workspace()->updateFocusMousePosition( QPoint( e->xcrossing.x_root, e->xcrossing.y_root ));
         break;
     }
     case XCB_FOCUS_IN:
         focusInEvent(reinterpret_cast<xcb_focus_in_event_t*>(e));
         break;
     case XCB_FOCUS_OUT:
         focusOutEvent(reinterpret_cast<xcb_focus_out_event_t*>(e));
         break;
     case XCB_REPARENT_NOTIFY:
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     case XCB_EXPOSE: {
         xcb_expose_event_t *event = reinterpret_cast<xcb_expose_event_t*>(e);
         if (event->window == frameId() && !Compositor::self()->isActive()) {
             // TODO: only repaint required areas
             triggerDecorationRepaint();
         }
         break;
     }
     default:
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent() && reinterpret_cast<xcb_shape_notify_event_t*>(e)->affected_window == window()) {
             detectShape(window());  // workaround for #19644
             updateShape();
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent() && reinterpret_cast<xcb_damage_notify_event_t*>(e)->drawable == frameId())
             damageNotifyEvent();
         break;
     }
     return true; // eat all events
 }
 
 /*!
   Handles map requests of the client window
  */
 bool Client::mapRequestEvent(xcb_map_request_event_t *e)
 {
     if (e->window != window()) {
         // Special support for the save-set feature, which is a bit broken.
         // If there's a window from one client embedded in another one,
         // e.g. using XEMBED, and the embedder suddenly loses its X connection,
         // save-set will reparent the embedded window to its closest ancestor
         // that will remains. Unfortunately, with reparenting window managers,
         // this is not the root window, but the frame (or in KWin's case,
         // it's the wrapper for the client window). In this case,
         // the wrapper will get ReparentNotify for a window it won't know,
         // which will be ignored, and then it gets MapRequest, as save-set
         // always maps. Returning true here means that Workspace::workspaceEvent()
         // will handle this MapRequest and manage this window (i.e. act as if
         // it was reparented to root window).
         if (e->parent == wrapperId())
             return false;
         return true; // no messing with frame etc.
     }
     // also copied in clientMessage()
     if (isMinimized())
         unminimize();
     if (isShade())
         setShade(ShadeNone);
     if (!isOnCurrentDesktop()) {
         if (workspace()->allowClientActivation(this))
             workspace()->activateClient(this);
         else
             demandAttention();
     }
     return true;
 }
 
 /*!
   Handles unmap notify events of the client window
  */
 void Client::unmapNotifyEvent(xcb_unmap_notify_event_t *e)
 {
     if (e->window != window())
         return;
     if (e->event != wrapperId()) {
         // most probably event from root window when initially reparenting
         bool ignore = true;
         if (e->event == rootWindow() && (e->response_type & 0x80))
             ignore = false; // XWithdrawWindow()
         if (ignore)
             return;
     }
 
     // check whether this is result of an XReparentWindow - client then won't be parented by wrapper
     // in this case do not release the client (causes reparent to root, removal from saveSet and what not)
     // but just destroy the client
     Xcb::Tree tree(m_client);
     xcb_window_t daddy = tree.parent();
     if (daddy == m_wrapper) {
         releaseWindow(); // unmapped from a regular client state
     } else {
         destroyClient(); // the client was moved to some other parent
     }
 }
 
 void Client::destroyNotifyEvent(xcb_destroy_notify_event_t *e)
 {
     if (e->window != window())
         return;
     destroyClient();
 }
 
 
 /*!
    Handles client messages for the client window
 */
 void Client::clientMessageEvent(xcb_client_message_event_t *e)
 {
     Toplevel::clientMessageEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     // WM_STATE
     if (e->type == atoms->wm_change_state) {
         if (e->data.data32[0] == XCB_ICCCM_WM_STATE_ICONIC)
             minimize();
         return;
     }
 }
 
 
 /*!
   Handles configure  requests of the client window
  */
 void Client::configureRequestEvent(xcb_configure_request_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     if (isResize() || isMove())
         return; // we have better things to do right now
 
     if (fullscreen_mode == FullScreenNormal) { // refuse resizing of fullscreen windows
         // but allow resizing fullscreen hacks in order to let them cancel fullscreen mode
         sendSyntheticConfigureNotify();
         return;
     }
     if (isSplash()) {  // no manipulations with splashscreens either
         sendSyntheticConfigureNotify();
         return;
     }
 
     if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
         // first, get rid of a window border
         m_client.setBorderWidth(0);
     }
 
     if (e->value_mask & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_WIDTH))
         configureRequest(e->value_mask, e->x, e->y, e->width, e->height, 0, false);
 
     if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE)
         restackWindow(e->sibling, e->stack_mode, NET::FromApplication, userTime(), false);
 
     // Sending a synthetic configure notify always is fine, even in cases where
     // the ICCCM doesn't require this - it can be though of as 'the WM decided to move
     // the window later'. The client should not cause that many configure request,
     // so this should not have any significant impact. With user moving/resizing
     // the it should be optimized though (see also Client::setGeometry()/plainResize()/move()).
     sendSyntheticConfigureNotify();
 
     // SELI TODO accept configure requests for isDesktop windows (because kdesktop
     // may get XRANDR resize event before kwin), but check it's still at the bottom?
 }
 
 
 /*!
   Handles property changes of the client window
  */
 void Client::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     Toplevel::propertyNotifyEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     case XCB_ATOM_WM_NORMAL_HINTS:
         getWmNormalHints();
         break;
     case XCB_ATOM_WM_NAME:
         fetchName();
         break;
     case XCB_ATOM_WM_ICON_NAME:
         fetchIconicName();
         break;
     case XCB_ATOM_WM_TRANSIENT_FOR:
         readTransient();
         break;
     case XCB_ATOM_WM_HINTS:
         getIcons(); // because KWin::icon() uses WMHints as fallback
         break;
     default:
         if (e->atom == atoms->motif_wm_hints) {
             getMotifHints();
         } else if (e->atom == atoms->net_wm_sync_request_counter)
             getSyncCounter();
         else if (e->atom == atoms->activities)
             checkActivities();
         else if (e->atom == atoms->kde_first_in_window_list)
             updateFirstInTabBox();
         else if (e->atom == atoms->kde_color_sheme)
             updateColorScheme();
         else if (e->atom == atoms->kde_screen_edge_show)
             updateShowOnScreenEdge();
         else if (e->atom == atoms->gtk_frame_extents)
             detectGtkFrameExtents();
         else if (e->atom == atoms->kde_net_wm_appmenu_service_name)
             checkApplicationMenuServiceName();
         else if (e->atom == atoms->kde_net_wm_appmenu_object_path)
             checkApplicationMenuObjectPath();
         break;
     }
 }
 
 
 void Client::enterNotifyEvent(xcb_enter_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about entering the whole frame
 
 #define MOUSE_DRIVEN_FOCUS (!options->focusPolicyIsReasonable() || \
                             (options->focusPolicy() == Options::FocusFollowsMouse && options->isNextFocusPrefersMouse()))
     if (e->mode == XCB_NOTIFY_MODE_NORMAL || (e->mode == XCB_NOTIFY_MODE_UNGRAB && MOUSE_DRIVEN_FOCUS)) {
 
         if (options->isShadeHover()) {
             cancelShadeHoverTimer();
             if (isShade()) {
                 shadeHoverTimer = new QTimer(this);
                 connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeHover()));
                 shadeHoverTimer->setSingleShot(true);
                 shadeHoverTimer->start(options->shadeHoverInterval());
             }
         }
 #undef MOUSE_DRIVEN_FOCUS
 
         enterEvent(QPoint(e->root_x, e->root_y));
         return;
     }
 }
 
 void Client::leaveNotifyEvent(xcb_leave_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about leaving the whole frame
     if (e->mode == XCB_NOTIFY_MODE_NORMAL) {
         if (!isMoveResizePointerButtonDown()) {
             setMoveResizePointerMode(PositionCenter);
             updateCursor();
         }
         bool lostMouse = !rect().contains(QPoint(e->event_x, e->event_y));
         // 'lostMouse' wouldn't work with e.g. B2 or Keramik, which have non-rectangular decorations
         // (i.e. the LeaveNotify event comes before leaving the rect and no LeaveNotify event
         // comes after leaving the rect) - so lets check if the pointer is really outside the window
 
         // TODO this still sucks if a window appears above this one - it should lose the mouse
         // if this window is another client, but not if it's a popup ... maybe after KDE3.1 :(
         // (repeat after me 'AARGHL!')
         if (!lostMouse && e->detail != XCB_NOTIFY_DETAIL_INFERIOR) {
             Xcb::Pointer pointer(frameId());
             if (!pointer || !pointer->same_screen || pointer->child == XCB_WINDOW_NONE) {
                 // really lost the mouse
                 lostMouse = true;
             }
         }
         if (lostMouse) {
             leaveEvent();
             cancelShadeHoverTimer();
             if (shade_mode == ShadeHover && !isMoveResize() && !isMoveResizePointerButtonDown()) {
                 shadeHoverTimer = new QTimer(this);
                 connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeUnhover()));
                 shadeHoverTimer->setSingleShot(true);
                 shadeHoverTimer->start(options->shadeHoverInterval());
             }
             if (isDecorated()) {
                 // sending a move instead of a leave. With leave we need to send proper coords, with move it's handled internally
                 QHoverEvent leaveEvent(QEvent::HoverMove, QPointF(-1, -1), QPointF(-1, -1), Qt::NoModifier);
                 QCoreApplication::sendEvent(decoration(), &leaveEvent);
             }
         }
         if (options->focusPolicy() == Options::FocusStrictlyUnderMouse && isActive() && lostMouse) {
             workspace()->requestDelayFocus(0);
         }
         return;
     }
 }
 
 #define XCapL KKeyServer::modXLock()
 #define XNumL KKeyServer::modXNumLock()
 #define XScrL KKeyServer::modXScrollLock()
 void Client::grabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, modifier | mods[ i ]);
 }
 
 void Client::ungrabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.ungrabButton(modifier | mods[ i ]);
 }
 #undef XCapL
 #undef XNumL
 #undef XScrL
 
 /*
   Releases the passive grab for some modifier combinations when a
   window becomes active. This helps broken X programs that
   missinterpret LeaveNotify events in grab mode to work properly
   (Motif, AWT, Tk, ...)
  */
 void Client::updateMouseGrab()
 {
     if (workspace()->globalShortcutsDisabled()) {
         m_wrapper.ungrabButton();
         // keep grab for the simple click without modifiers if needed (see below)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!(!options->isClickRaise() || not_obscured))
             grabButton(XCB_NONE);
         return;
     }
     if (isActive() && !TabBox::TabBox::self()->forcedGlobalMouseGrab()) { // see TabBox::establishTabBoxGrab()
         // first grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
         // remove the grab for no modifiers only if the window
         // is unobscured or if the user doesn't want click raise
         // (it is unobscured if it the topmost in the unconstrained stacking order, i.e. it is
         // the most recently raised window)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!options->isClickRaise() || not_obscured)
             ungrabButton(XCB_NONE);
         else
             grabButton(XCB_NONE);
         ungrabButton(XCB_MOD_MASK_SHIFT);
         ungrabButton(XCB_MOD_MASK_CONTROL);
         ungrabButton(XCB_MOD_MASK_CONTROL | XCB_MOD_MASK_SHIFT);
     } else {
         m_wrapper.ungrabButton();
         // simply grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
     }
 }
 
 static bool modKeyDown(int state) {
     const uint keyModX = (options->keyCmdAllModKey() == Qt::Key_Meta) ?
                                                     KKeyServer::modXMeta() : KKeyServer::modXAlt();
     return keyModX  && (state & KKeyServer::accelModMaskX()) == keyModX;
 }
 
 
 // return value matters only when filtering events before decoration gets them
 bool Client::buttonPressEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root, xcb_timestamp_t time)
 {
     if (isMoveResizePointerButtonDown()) {
         if (w == wrapperId())
             xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
 
     if (w == wrapperId() || w == frameId() || w == inputId()) {
         // FRAME neco s tohohle by se melo zpracovat, nez to dostane dekorace
         updateUserTime(time);
-        workspace()->setWasUserInteraction();
         const bool bModKeyHeld = modKeyDown(state);
 
         if (isSplash()
                 && button == XCB_BUTTON_INDEX_1 && !bModKeyHeld) {
             // hide splashwindow if the user clicks on it
             hideClient(true);
             if (w == wrapperId())
                 xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
 
         Options::MouseCommand com = Options::MouseNothing;
         bool was_action = false;
         if (bModKeyHeld) {
             was_action = true;
             switch(button) {
             case XCB_BUTTON_INDEX_1:
                 com = options->commandAll1();
                 break;
             case XCB_BUTTON_INDEX_2:
                 com = options->commandAll2();
                 break;
             case XCB_BUTTON_INDEX_3:
                 com = options->commandAll3();
                 break;
             case XCB_BUTTON_INDEX_4:
             case XCB_BUTTON_INDEX_5:
                 com = options->operationWindowMouseWheel(button == XCB_BUTTON_INDEX_4 ? 120 : -120);
                 break;
             }
         } else {
             if (w == wrapperId()) {
                 if (button < 4) {
                     com = getMouseCommand(x11ToQtMouseButton(button), &was_action);
                 } else if (button < 6) {
                     com = getWheelCommand(Qt::Vertical, &was_action);
                 }
             }
         }
         if (was_action) {
             bool replay = performMouseCommand(com, QPoint(x_root, y_root));
 
             if (isSpecialWindow())
                 replay = true;
 
             if (w == wrapperId())  // these can come only from a grab
                 xcb_allow_events(connection(), replay ? XCB_ALLOW_REPLAY_POINTER : XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
     }
 
     if (w == wrapperId()) { // these can come only from a grab
         xcb_allow_events(connection(), XCB_ALLOW_REPLAY_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w == inputId()) {
         x = x_root - geometry().x();
         y = y_root - geometry().y();
         // New API processes core events FIRST and only passes unused ones to the decoration
         QMouseEvent ev(QMouseEvent::MouseButtonPress, QPoint(x, y), QPoint(x_root, y_root),
                        x11ToQtMouseButton(button), x11ToQtMouseButtons(state), Qt::KeyboardModifiers());
         return processDecorationButtonPress(&ev, true);
     }
     if (w == frameId() && isDecorated()) {
         if (button >= 4 && button <= 7) {
             const Qt::KeyboardModifiers modifiers = x11ToQtKeyboardModifiers(state);
             // Logic borrowed from qapplication_x11.cpp
             const int delta = 120 * ((button == 4 || button == 6) ? 1 : -1);
             const bool hor = (((button == 4 || button == 5) && (modifiers & Qt::AltModifier))
                              || (button == 6 || button == 7));
 
             const QPoint angle = hor ? QPoint(delta, 0) : QPoint(0, delta);
             QWheelEvent event(QPointF(x, y),
                               QPointF(x_root, y_root),
                               QPoint(),
                               angle,
                               delta,
                               hor ? Qt::Horizontal : Qt::Vertical,
                               x11ToQtMouseButtons(state),
                               modifiers);
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted() && !hor) {
                 if (titlebarPositionUnderMouse()) {
                     performMouseCommand(options->operationTitlebarMouseWheel(delta), QPoint(x_root, y_root));
                 }
             }
         } else {
             QMouseEvent event(QEvent::MouseButtonPress, QPointF(x, y), QPointF(x_root, y_root),
                             x11ToQtMouseButton(button), x11ToQtMouseButtons(state), x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted()) {
                 processDecorationButtonPress(&event);
             }
         }
         return true;
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool Client::buttonReleaseEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated()) {
         // wheel handled on buttonPress
         if (button < 4 || button > 7) {
             QMouseEvent event(QEvent::MouseButtonRelease,
                               QPointF(x, y),
                               QPointF(x_root, y_root),
                               x11ToQtMouseButton(button),
                               x11ToQtMouseButtons(state) & ~x11ToQtMouseButton(button),
                               x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (event.isAccepted() || !titlebarPositionUnderMouse()) {
                 invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
             }
         }
     }
     if (w == wrapperId()) {
         xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true;
     if (w == frameId() && workspace()->userActionsMenu() && workspace()->userActionsMenu()->isShown()) {
         const_cast<UserActionsMenu*>(workspace()->userActionsMenu())->grabInput();
     }
     x = this->x(); // translate from grab window to local coords
     y = this->y();
 
     // Check whether other buttons are still left pressed
     int buttonMask = XCB_BUTTON_MASK_1 | XCB_BUTTON_MASK_2 | XCB_BUTTON_MASK_3;
     if (button == XCB_BUTTON_INDEX_1)
         buttonMask &= ~XCB_BUTTON_MASK_1;
     else if (button == XCB_BUTTON_INDEX_2)
         buttonMask &= ~XCB_BUTTON_MASK_2;
     else if (button == XCB_BUTTON_INDEX_3)
         buttonMask &= ~XCB_BUTTON_MASK_3;
 
     if ((state & buttonMask) == 0) {
         endMoveResize();
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool Client::motionNotifyEvent(xcb_window_t w, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated() && !isMinimized()) {
         // TODO Mouse move event dependent on state
         QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
         QCoreApplication::instance()->sendEvent(decoration(), &event);
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true; // care only about the whole frame
     if (!isMoveResizePointerButtonDown()) {
         if (w == inputId()) {
             int x = x_root - geometry().x();// + padding_left;
             int y = y_root - geometry().y();// + padding_top;
 
             if (isDecorated()) {
                 QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
                 QCoreApplication::instance()->sendEvent(decoration(), &event);
             }
         }
         Position newmode = modKeyDown(state) ? PositionCenter : mousePosition();
         if (newmode != moveResizePointerMode()) {
             setMoveResizePointerMode(newmode);
             updateCursor();
         }
         return false;
     }
     if (w == moveResizeGrabWindow()) {
         x = this->x(); // translate from grab window to local coords
         y = this->y();
     }
 
     handleMoveResize(QPoint(x, y), QPoint(x_root, y_root));
     return true;
 }
 
 void Client::focusInEvent(xcb_focus_in_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_UNGRAB)
         return; // we don't care
     if (e->detail == XCB_NOTIFY_DETAIL_POINTER)
         return;  // we don't care
     if (!isShown(false) || !isOnCurrentDesktop())    // we unmapped it, but it got focus meanwhile ->
         return;            // activateNextClient() already transferred focus elsewhere
     workspace()->forEachClient([](Client *client) {
         client->cancelFocusOutTimer();
     });
     // check if this client is in should_get_focus list or if activation is allowed
     bool activate =  workspace()->allowClientActivation(this, -1U, true);
     workspace()->gotFocusIn(this);   // remove from should_get_focus list
     if (activate)
         setActive(true);
     else {
         workspace()->restoreFocus();
         demandAttention();
     }
 }
 
 void Client::focusOutEvent(xcb_focus_out_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_GRAB)
         return; // we don't care
     if (isShade())
         return; // here neither
     if (e->detail != XCB_NOTIFY_DETAIL_NONLINEAR
             && e->detail != XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL)
         // SELI check all this
         return; // hack for motif apps like netscape
     if (QApplication::activePopupWidget())
         return;
 
     // When a client loses focus, FocusOut events are usually immediatelly
     // followed by FocusIn events for another client that gains the focus
     // (unless the focus goes to another screen, or to the nofocus widget).
     // Without this check, the former focused client would have to be
     // deactivated, and after that, the new one would be activated, with
     // a short time when there would be no active client. This can cause
     // flicker sometimes, e.g. when a fullscreen is shown, and focus is transferred
     // from it to its transient, the fullscreen would be kept in the Active layer
     // at the beginning and at the end, but not in the middle, when the active
     // client would be temporarily none (see Client::belongToLayer() ).
     // Therefore the setActive(false) call is moved to the end of the current
     // event queue. If there is a matching FocusIn event in the current queue
     // this will be processed before the setActive(false) call and the activation
     // of the Client which gained FocusIn will automatically deactivate the
     // previously active client.
     if (!m_focusOutTimer) {
         m_focusOutTimer = new QTimer(this);
         m_focusOutTimer->setSingleShot(true);
         m_focusOutTimer->setInterval(0);
         connect(m_focusOutTimer, &QTimer::timeout, [this]() {
             setActive(false);
         });
     }
     m_focusOutTimer->start();
 }
 
 // performs _NET_WM_MOVERESIZE
 void Client::NETMoveResize(int x_root, int y_root, NET::Direction direction)
 {
     if (direction == NET::Move) {
         // move cursor to the provided position to prevent the window jumping there on first movement
         // the expectation is that the cursor is already at the provided position,
         // thus it's more a safety measurement
         Cursor::setPos(QPoint(x_root, y_root));
         performMouseCommand(Options::MouseMove, QPoint(x_root, y_root));
     } else if (isMoveResize() && direction == NET::MoveResizeCancel) {
         finishMoveResize(true);
         setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction >= NET::TopLeft && direction <= NET::Left) {
         static const Position convert[] = {
             PositionTopLeft,
             PositionTop,
             PositionTopRight,
             PositionRight,
             PositionBottomRight,
             PositionBottom,
             PositionBottomLeft,
             PositionLeft
         };
         if (!isResizable() || isShade())
             return;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(x_root - x(), y_root - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         setMoveResizePointerMode(convert[ direction ]);
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction == NET::KeyboardMove) {
         // ignore mouse coordinates given in the message, mouse position is used by the moving algorithm
         Cursor::setPos(geometry().center());
         performMouseCommand(Options::MouseUnrestrictedMove, geometry().center());
     } else if (direction == NET::KeyboardSize) {
         // ignore mouse coordinates given in the message, mouse position is used by the resizing algorithm
         Cursor::setPos(geometry().bottomRight());
         performMouseCommand(Options::MouseUnrestrictedResize, geometry().bottomRight());
     }
 }
 
 void Client::keyPressEvent(uint key_code, xcb_timestamp_t time)
 {
     updateUserTime(time);
     AbstractClient::keyPressEvent(key_code);
 }
 
 void Client::syncEvent(xcb_sync_alarm_notify_event_t* e)
 {
     if (e->alarm == syncRequest.alarm && e->counter_value.hi == syncRequest.value.hi && e->counter_value.lo == syncRequest.value.lo) {
         setReadyForPainting();
         setupWindowManagementInterface();
         syncRequest.isPending = false;
         if (syncRequest.failsafeTimeout)
             syncRequest.failsafeTimeout->stop();
         if (isResize()) {
             if (syncRequest.timeout)
                 syncRequest.timeout->stop();
             performMoveResize();
         } else // setReadyForPainting does as well, but there's a small chance for resize syncs after the resize ended
             addRepaintFull();
     }
 }
 
 // ****************************************
 // Unmanaged
 // ****************************************
 
 bool Unmanaged::windowEvent(xcb_generic_event_t *e)
 {
     double old_opacity = opacity();
     NET::Properties dirtyProperties;
     NET::Properties2 dirtyProperties2;
     info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
     if (dirtyProperties2 & NET::WM2Opacity) {
         if (compositing()) {
             addRepaintFull();
             emit opacityChanged(this, old_opacity);
         }
     }
     if (dirtyProperties2 & NET::WM2OpaqueRegion) {
         getWmOpaqueRegion();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
         emit windowRoleChanged();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
         getResourceClass();
     }
     const uint8_t eventType = e->response_type & ~0x80;
     switch (eventType) {
     case XCB_DESTROY_NOTIFY:
         release(ReleaseReason::Destroyed);
         break;
     case XCB_UNMAP_NOTIFY:{
         workspace()->updateFocusMousePosition(Cursor::pos()); // may cause leave event
 
         // unmap notify might have been emitted due to a destroy notify
         // but unmap notify gets emitted before the destroy notify, nevertheless at this
         // point the window is already destroyed. This means any XCB request with the window
         // will cause an error.
         // To not run into these errors we try to wait for the destroy notify. For this we
         // generate a round trip to the X server and wait a very short time span before
         // handling the release.
         updateXTime();
         // using 1 msec to not just move it at the end of the event loop but add an very short
         // timespan to cover cases like unmap() followed by destroy(). The only other way to
         // ensure that the window is not destroyed when we do the release handling is to grab
         // the XServer which we do not want to do for an Unmanaged. The timespan of 1 msec is
         // short enough to not cause problems in the close window animations.
         // It's of course still possible that we miss the destroy in which case non-fatal
         // X errors are reported to the event loop and logged by Qt.
         QTimer::singleShot(1, this, SLOT(release()));
         break;
     }
     case XCB_CONFIGURE_NOTIFY:
         configureNotifyEvent(reinterpret_cast<xcb_configure_notify_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     default: {
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             detectShape(window());
             addRepaintFull();
             addWorkspaceRepaint(geometry());  // in case shape change removes part of this window
             emit geometryShapeChanged(this, geometry());
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent())
             damageNotifyEvent();
         break;
     }
     }
     return false; // don't eat events, even our own unmanaged widgets are tracked
 }
 
 void Unmanaged::configureNotifyEvent(xcb_configure_notify_event_t *e)
 {
     if (effects)
         static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking(); // keep them on top
     QRect newgeom(e->x, e->y, e->width, e->height);
     if (newgeom != geom) {
         addWorkspaceRepaint(visibleRect());  // damage old area
         QRect old = geom;
         geom = newgeom;
         emit geometryChanged(); // update shadow region
         addRepaintFull();
         if (old.size() != geom.size())
             discardWindowPixmap();
         emit geometryShapeChanged(this, old);
     }
 }
 
 // ****************************************
 // Toplevel
 // ****************************************
 
 void Toplevel::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     default:
         if (e->atom == atoms->wm_client_leader)
             getWmClientLeader();
         else if (e->atom == atoms->kde_net_wm_shadow)
             getShadow();
         else if (e->atom == atoms->kde_skip_close_animation)
             getSkipCloseAnimation();
         break;
     }
     emit propertyNotify(this, e->atom);
 }
 
 void Toplevel::clientMessageEvent(xcb_client_message_event_t *e)
 {
     if (e->type == atoms->wl_surface_id) {
         m_surfaceId = e->data.data32[0];
         if (auto w = waylandServer()) {
             if (auto s = KWayland::Server::SurfaceInterface::get(m_surfaceId, w->xWaylandConnection())) {
                 setSurface(s);
             }
         }
         emit surfaceIdChanged(m_surfaceId);
     }
 }
 
 } // namespace
diff --git a/was_user_interaction_x11_filter.cpp b/was_user_interaction_x11_filter.cpp
new file mode 100644
index 000000000..1cc33710a
--- /dev/null
+++ b/was_user_interaction_x11_filter.cpp
@@ -0,0 +1,38 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#include "was_user_interaction_x11_filter.h"
+#include "workspace.h"
+#include <xcb/xcb.h>
+
+namespace KWin
+{
+WasUserInteractionX11Filter::WasUserInteractionX11Filter()
+    : X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE, XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE})
+{
+}
+
+bool WasUserInteractionX11Filter::event(xcb_generic_event_t *event)
+{
+    Q_UNUSED(event);
+    workspace()->setWasUserInteraction();
+    return false;
+}
+
+}
diff --git a/was_user_interaction_x11_filter.h b/was_user_interaction_x11_filter.h
new file mode 100644
index 000000000..b1212b713
--- /dev/null
+++ b/was_user_interaction_x11_filter.h
@@ -0,0 +1,37 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#ifndef KWIN_WAS_USER_INTERACTION_X11_FILTER_H
+#define KWIN_WAS_USER_INTERACTION_X11_FILTER_H
+#include "x11eventfilter.h"
+
+namespace KWin
+{
+
+class WasUserInteractionX11Filter : public X11EventFilter
+{
+public:
+    explicit WasUserInteractionX11Filter();
+
+    bool event(xcb_generic_event_t *event) override;
+};
+
+}
+
+#endif
diff --git a/workspace.cpp b/workspace.cpp
index 4c2d5f755..189afada3 100644
--- a/workspace.cpp
+++ b/workspace.cpp
@@ -1,1790 +1,1808 @@
 /********************************************************************
  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>
 #include <kwinxrenderutils.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 "killwindow.h"
 #include "netinfo.h"
 #include "outline.h"
 #include "placement.h"
 #include "rules.h"
 #include "screenedge.h"
 #include "screens.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;
 
     // first initialize the extensions
     Xcb::Extensions::self();
 
 #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);
     ColorMapper *colormaps = new ColorMapper(this);
     connect(this, &Workspace::clientActivated, colormaps, &ColorMapper::update);
 
     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();
 
     // Call this before XSelectInput() on the root window
     startup = new KStartupInfo(
         KStartupInfo::DisableKWinModule | KStartupInfo::AnnounceSilenceChanges, this);
 
     // Select windowmanager privileges
     selectWmInputEventMask();
 
     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);
 
 #ifdef KWIN_BUILD_TABBOX
     // need to create the tabbox before compositing scene is setup
     TabBox::TabBox::create(this);
 #endif
 
     // init XRenderUtils
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         XRenderUtils::init(connection(), rootWindow());
     }
     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);
 
     // Compatibility
     int32_t data = 1;
 
     xcb_change_property(connection(), XCB_PROP_MODE_APPEND, rootWindow(), atoms->kwin_running,
                         atoms->kwin_running, 32, 1, &data);
 
     Outline::create(this);
 
     initShortcuts();
 
     init();
 }
 
 void Workspace::init()
 {
+    if (kwinApp()->operationMode() == Application::OperationModeX11) {
+        m_wasUserInteractionFilter.reset(new WasUserInteractionX11Filter);
+    }
     updateXTime(); // Needed for proper initialization of user_time in Client ctor
     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());
 
     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();
 
     // create VirtualDesktopManager and perform dependency injection
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(vds, SIGNAL(desktopsRemoved(uint)), SLOT(moveClientsFromRemovedDesktops()));
     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->setRootInfo(rootInfo);
     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();
 
     // 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);
 
     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;
     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
 
     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);
 
     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()) {
                     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()
 }
 
 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);
     xcb_delete_property(connection(), rootWindow(), 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();
 
     if (kwinApp()->operationMode() == Application::OperationModeX11) {
         XRenderUtils::cleanup();
     }
     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);
 }
 
 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);
     checkNonExistentClients();
 #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)
 {
     emit clientRemoved(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();
 
     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);
 }
 
 /**
  * This D-Bus call is used by the compositing kcm. Since the reconfigure()
  * D-Bus call delays the actual reconfiguring, it is not possible to immediately
  * call compositingActive(). Therefore the kcm will instead call this to ensure
  * the reconfiguring has already happened.
  */
 bool Workspace::waitForCompositingSetup()
 {
     if (reconfigureTimer.isActive()) {
         reconfigureTimer.stop();
         slotReconfigure();
     }
     if (m_compositor) {
         return m_compositor->isActive();
     }
     return false;
 }
 
 /**
  * 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 (ClientList::Iterator it = clients.begin();
             it != clients.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 (ClientList::Iterator it = clients.begin();
                 it != clients.end();
                 ++it) {
             if ((*it)->maximizeMode() == MaximizeFull)
                 (*it)->checkNoBorder();
         }
     }
 }
 
 /**
  * During virt. desktop switching, desktop areas covered by windows that are
  * going to be hidden are first obscured by new windows with no background
  * ( i.e. transparent ) placed right below the windows. These invisible windows
  * are removed after the switch is complete.
  * Reduces desktop ( wallpaper ) repaints during desktop switching
  */
 class ObscuringWindows
 {
 public:
     ~ObscuringWindows();
     void create(Client* c);
 private:
     QList<xcb_window_t> obscuring_windows;
     static QList<xcb_window_t>* cached;
     static unsigned int max_cache_size;
 };
 
 QList<xcb_window_t>* ObscuringWindows::cached = nullptr;
 unsigned int ObscuringWindows::max_cache_size = 0;
 
 void ObscuringWindows::create(Client* c)
 {
     if (!cached)
         cached = new QList<xcb_window_t>;
     Xcb::Window obs_win(XCB_WINDOW_NONE, false);
     if (cached->count() > 0) {
         obs_win.reset(cached->first(), false);
         cached->removeAll(obs_win);
         obs_win.setGeometry(c->geometry());
     } else {
         uint32_t values[] = {XCB_PIXMAP_NONE, true};
         obs_win.create(c->geometry(), XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_CW_BACK_PIXMAP | XCB_CW_OVERRIDE_REDIRECT, values);
     }
     uint32_t values[] = {c->frameId(), XCB_STACK_MODE_BELOW};
     xcb_configure_window(connection(), obs_win, XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE, values);
     obs_win.map();
     obscuring_windows.append(obs_win);
 }
 
 ObscuringWindows::~ObscuringWindows()
 {
     max_cache_size = qMax(int(max_cache_size), obscuring_windows.count() + 4) - 1;
     for (auto it = obscuring_windows.constBegin();
             it != obscuring_windows.constEnd();
             ++it) {
         xcb_unmap_window(connection(), *it);
         if (cached->count() < int(max_cache_size))
             cached->prepend(*it);
         else
             xcb_destroy_window(connection(), *it);
     }
 }
 
 void Workspace::slotCurrentDesktopChanged(uint oldDesktop, uint newDesktop)
 {
     closeActivePopup();
     ++block_focus;
     StackingUpdatesBlocker blocker(this);
     updateClientVisibilityOnDesktopChange(oldDesktop, newDesktop);
     // Restore the focus on this desktop
     --block_focus;
 
     activateClientOnNewDesktop(newDesktop);
     emit currentDesktopChanged(oldDesktop, movingClient);
 }
 
 void Workspace::updateClientVisibilityOnDesktopChange(uint oldDesktop, uint newDesktop)
 {
     ObscuringWindows obs_wins;
     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()) {
             if (c->isShown(true) && c->isOnDesktop(oldDesktop) && !compositing())
                 obs_wins.create(c);
             (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));
 
     ObscuringWindows obs_wins;
 
     const QString &old_activity = Activities::self()->previous();
 
     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()) {
             if (c->isShown(true) && c->isOnActivity(old_activity) && !compositing())
                 obs_wins.create(c);
             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::moveClientsFromRemovedDesktops()
 {
     for (ClientList::ConstIterator it = clients.constBegin(); it != clients.constEnd(); ++it) {
         if (!(*it)->isOnAllDesktops() && (*it)->desktop() > static_cast<int>(VirtualDesktopManager::self()->count()))
             sendClientToDesktop(*it, VirtualDesktopManager::self()->count(), true);
     }
 }
 
 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 );
 
     if (Client *client = dynamic_cast<Client*>(c)) {
         // TODO: adjust transients for non-X11
         auto transients_stacking_order = ensureStackingOrder(client->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()
 {
     m_nullFocus->focus();
 }
 
 void Workspace::setShowingDesktop(bool showing)
 {
     const bool changed = showing != showing_desktop;
     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. http://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::OperationModeWaylandAndX11:
         support.append(QStringLiteral("Wayland and X11"));
         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_INPUT: "));
 #if HAVE_INPUT
     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"));
 
     support.append(QStringLiteral("X11\n"));
     support.append(QStringLiteral("===\n"));
     auto x11setup = xcb_get_setup(connection());
     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("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").arg(i));
         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("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;
 }
 
 void Workspace::slotToggleCompositing()
 {
     if (m_compositor) {
         m_compositor->slotToggleCompositing();
     }
 }
 
 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_xStackingQueryTree.reset(new Xcb::Tree(rootWindow()));
 }
 
+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
 
diff --git a/workspace.h b/workspace.h
index 203004306..c883f74b3 100644
--- a/workspace.h
+++ b/workspace.h
@@ -1,768 +1,764 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_WORKSPACE_H
 #define KWIN_WORKSPACE_H
 
 // kwin
 #include "sm.h"
 #include "options.h"
 #include "utils.h"
 // Qt
 #include <QTimer>
 #include <QVector>
 // std
 #include <functional>
 #include <memory>
 
 // TODO: Cleanup the order of things in this .h file
 
 class QStringList;
 class KConfig;
 class KConfigGroup;
 class KStartupInfo;
 class KStartupInfoId;
 class KStartupInfoData;
 
 namespace KWin
 {
 
 namespace Xcb
 {
 class Tree;
 class Window;
 }
 
 class AbstractClient;
 class Client;
 class KillWindow;
 class ShortcutDialog;
 class UserActionsMenu;
 class Compositor;
 class X11EventFilter;
 enum class Predicate;
 
 class KWIN_EXPORT Workspace : public QObject
 {
     Q_OBJECT
 public:
     explicit Workspace(const QString &sessionKey = QString());
     virtual ~Workspace();
 
     static Workspace* self() {
         return _self;
     }
 
     bool workspaceEvent(xcb_generic_event_t*);
     bool workspaceEvent(QEvent*);
 
     bool hasClient(const Client*);
     bool hasClient(const AbstractClient*);
 
     /**
      * @brief Finds the first Client matching the condition expressed by passed in @p func.
      *
      * Internally findClient uses the std::find_if algorithm and that determines how the function
      * needs to be implemented. An example usage for finding a Client with a matching windowId
      * @code
      * xcb_window_t w; // our test window
      * Client *client = findClient([w](const Client *c) -> bool {
      *     return c->window() == w;
      * });
      * @endcode
      *
      * For the standard cases of matching the window id with one of the Client's windows use
      * the simplified overload method findClient(Predicate, xcb_window_t). Above example
      * can be simplified to:
      * @code
      * xcb_window_t w; // our test window
      * Client *client = findClient(Predicate::WindowMatch, w);
      * @endcode
      *
      * @param func Unary function that accepts a Client* as argument and
      * returns a value convertible to bool. The value returned indicates whether the
      * Client* is considered a match in the context of this function.
      * The function shall not modify its argument.
      * This can either be a function pointer or a function object.
      * @return KWin::Client* The found Client or @c null
      * @see findClient(Predicate, xcb_window_t)
      */
     Client *findClient(std::function<bool (const Client*)> func) const;
     AbstractClient *findAbstractClient(std::function<bool (const AbstractClient*)> func) const;
     /**
      * @brief Finds the Client matching the given match @p predicate for the given window.
      *
      * @param predicate Which window should be compared
      * @param w The window id to test against
      * @return KWin::Client* The found Client or @c null
      * @see findClient(std::function<bool (const Client*)>)
      */
     Client *findClient(Predicate predicate, xcb_window_t w) const;
     void forEachClient(std::function<void (Client*)> func);
     void forEachAbstractClient(std::function<void (AbstractClient*)> func);
     Unmanaged *findUnmanaged(std::function<bool (const Unmanaged*)> func) const;
     /**
      * @brief Finds the Unmanaged with the given window id.
      *
      * @param w The window id to search for
      * @return KWin::Unmanaged* Found Unmanaged or @c null if there is no Unmanaged with given Id.
      */
     Unmanaged *findUnmanaged(xcb_window_t w) const;
     void forEachUnmanaged(std::function<void (Unmanaged*)> func);
     Toplevel *findToplevel(std::function<bool (const Toplevel*)> func) const;
     /**
      * Finds the Toplevel for the KWin internal window @p w.
      * On Wayland this is normally a ShellClient. For X11 an Unmanaged.
      **/
     Toplevel *findToplevel(QWindow *w) const;
     /**
      * @brief Finds a Toplevel for the internal window @p w.
      *
      * Internal window means a window created by KWin itself. On X11 this is an Unmanaged
      * and mapped by the window id, on Wayland a ShellClient mapped on the internal window id.
      *
      * @returns Toplevel
      **/
     Toplevel *findInternal(QWindow *w) const;
 
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const;
     QRect clientArea(clientAreaOption, const AbstractClient* c) const;
     QRect clientArea(clientAreaOption, int screen, int desktop) const;
 
     QRegion restrictedMoveArea(int desktop, StrutAreas areas = StrutAreaAll) const;
 
     bool initializing() const;
 
     /**
      * Returns the active client, i.e. the client that has the focus (or None
      * if no client has the focus)
      */
     AbstractClient* activeClient() const;
     /**
      * Client that was activated, but it's not yet really activeClient(), because
      * we didn't process yet the matching FocusIn event. Used mostly in focus
      * stealing prevention code.
      */
     AbstractClient* mostRecentlyActivatedClient() const;
 
     AbstractClient* clientUnderMouse(int screen) const;
 
     void activateClient(AbstractClient*, bool force = false);
     void requestFocus(AbstractClient* c, bool force = false);
     enum ActivityFlag {
         ActivityFocus = 1 << 0, // focus the window
         ActivityFocusForce = 1 << 1 | ActivityFocus, // focus even if Dock etc.
         ActivityRaise = 1 << 2 // raise the window
     };
     Q_DECLARE_FLAGS(ActivityFlags, ActivityFlag)
     void takeActivity(AbstractClient* c, ActivityFlags flags);
     bool allowClientActivation(const AbstractClient* c, xcb_timestamp_t time = -1U, bool focus_in = false,
                                bool ignore_desktop = false);
     void restoreFocus();
     void gotFocusIn(const AbstractClient*);
     void setShouldGetFocus(AbstractClient*);
     bool activateNextClient(AbstractClient* c);
     bool focusChangeEnabled() {
         return block_focus == 0;
     }
 
     /**
      * Indicates that the client c is being moved around by the user.
      */
     void setClientIsMoving(AbstractClient* c);
 
     QPoint adjustClientPosition(AbstractClient* c, QPoint pos, bool unrestricted, double snapAdjust = 1.0);
     QRect adjustClientSize(AbstractClient* c, QRect moveResizeGeom, int mode);
     void raiseClient(AbstractClient* c, bool nogroup = false);
     void lowerClient(AbstractClient* c, bool nogroup = false);
     void raiseClientRequest(AbstractClient* c, NET::RequestSource src = NET::FromApplication, xcb_timestamp_t timestamp = 0);
     void lowerClientRequest(Client* c, NET::RequestSource src, xcb_timestamp_t timestamp);
     void lowerClientRequest(AbstractClient* c);
     void restackClientUnderActive(AbstractClient*);
     void restack(AbstractClient *c, AbstractClient *under, bool force = false);
     void updateClientLayer(AbstractClient* c);
     void raiseOrLowerClient(AbstractClient*);
     void resetUpdateToolWindowsTimer();
     void restoreSessionStackingOrder(Client* c);
     void updateStackingOrder(bool propagate_new_clients = false);
     void forceRestacking();
 
     void clientHidden(AbstractClient*);
     void clientAttentionChanged(AbstractClient* c, bool set);
 
     /**
      * @return List of clients currently managed by Workspace
      **/
     const ClientList &clientList() const {
         return clients;
     }
     /**
      * @return List of unmanaged "clients" currently registered in Workspace
      **/
     const UnmanagedList &unmanagedList() const {
         return unmanaged;
     }
     /**
      * @return List of desktop "clients" currently managed by Workspace
      **/
     const ClientList &desktopList() const {
         return desktops;
     }
     /**
      * @return List of deleted "clients" currently managed by Workspace
      **/
     const DeletedList &deletedList() const {
         return deleted;
     }
     /**
      * @returns List of all clients (either X11 or Wayland) currently managed by Workspace
      **/
     const QList<AbstractClient*> allClientList() const {
         return m_allClients;
     }
 
     void stackScreenEdgesUnderOverrideRedirect();
 
 public:
     QPoint cascadeOffset(const AbstractClient *c) const;
 
 private:
     Compositor *m_compositor;
 
     //-------------------------------------------------
     // Unsorted
 
 public:
     bool isOnCurrentHead();
     // True when performing Workspace::updateClientArea().
     // The calls below are valid only in that case.
     bool inUpdateClientArea() const;
     QRegion previousRestrictedMoveArea(int desktop, StrutAreas areas = StrutAreaAll) const;
     QVector< QRect > previousScreenSizes() const;
     int oldDisplayWidth() const;
     int oldDisplayHeight() const;
 
     /**
      * Returns the list of clients sorted in stacking order, with topmost client
      * at the last position
      */
     const ToplevelList& stackingOrder() const;
     ToplevelList xStackingOrder() const;
     ClientList ensureStackingOrder(const ClientList& clients) const;
     QList<AbstractClient*> ensureStackingOrder(const QList<AbstractClient*> &clients) const;
 
     AbstractClient* topClientOnDesktop(int desktop, int screen, bool unconstrained = false,
                                bool only_normal = true) const;
     AbstractClient* findDesktop(bool topmost, int desktop) const;
     void sendClientToDesktop(AbstractClient* c, int desktop, bool dont_activate);
     void windowToPreviousDesktop(AbstractClient* c);
     void windowToNextDesktop(AbstractClient* c);
     void sendClientToScreen(AbstractClient* c, int screen);
 
     /**
      * Shows the menu operations menu for the client and makes it active if
      * it's not already.
      */
     void showWindowMenu(const QRect& pos, AbstractClient* cl);
     const UserActionsMenu *userActionsMenu() const {
         return m_userActionsMenu;
     }
 
     void showApplicationMenu(const QRect &pos, AbstractClient *c, int actionId);
 
     void updateMinimizedOfTransients(AbstractClient*);
     void updateOnAllDesktopsOfTransients(AbstractClient*);
     void checkTransients(xcb_window_t w);
 
     void storeSession(KConfig* config, SMSavePhase phase);
     void storeClient(KConfigGroup &cg, int num, Client *c);
     void storeSubSession(const QString &name, QSet<QByteArray> sessionIds);
     void loadSubSessionInfo(const QString &name);
 
     SessionInfo* takeSessionInfo(Client*);
 
     // D-Bus interface
     bool waitForCompositingSetup();
     QString supportInformation() const;
 
     void setCurrentScreen(int new_screen);
 
     void setShowingDesktop(bool showing);
     bool showingDesktop() const;
 
     void sendPingToWindow(xcb_window_t w, xcb_timestamp_t timestamp);   // Called from Client::pingWindow()
 
     void removeClient(Client*);   // Only called from Client::destroyClient() or Client::releaseWindow()
     void setActiveClient(AbstractClient*);
     Group* findGroup(xcb_window_t leader) const;
     void addGroup(Group* group);
     void removeGroup(Group* group);
     Group* findClientLeaderGroup(const Client* c) const;
 
     void removeUnmanaged(Unmanaged*);   // Only called from Unmanaged::release()
     void removeDeleted(Deleted*);
     void addDeleted(Deleted*, Toplevel*);
 
     bool checkStartupNotification(xcb_window_t w, KStartupInfoId& id, KStartupInfoData& data);
 
     void focusToNull(); // SELI TODO: Public?
 
     void clientShortcutUpdated(AbstractClient* c);
     bool shortcutAvailable(const QKeySequence &cut, AbstractClient* ignore = NULL) const;
     bool globalShortcutsDisabled() const;
     void disableGlobalShortcutsForClient(bool disable);
 
     void sessionSaveStarted();
     void sessionSaveDone();
     void setWasUserInteraction();
     bool wasUserInteraction() const;
     bool sessionSaving() const;
 
     int packPositionLeft(const AbstractClient* cl, int oldx, bool left_edge) const;
     int packPositionRight(const AbstractClient* cl, int oldx, bool right_edge) const;
     int packPositionUp(const AbstractClient* cl, int oldy, bool top_edge) const;
     int packPositionDown(const AbstractClient* cl, int oldy, bool bottom_edge) const;
 
     void cancelDelayFocus();
     void requestDelayFocus(AbstractClient*);
 
     /**
     * updates the mouse position to track whether a focus follow mouse focus change was caused by
     * an actual mouse move
     * is esp. called on enter/motion events of inactive windows
     * since an active window doesn't receive mouse events, it must also be invoked if a (potentially)
     * active window might be moved/resize away from the cursor (causing a leave event)
     */
     void updateFocusMousePosition(const QPoint& pos);
     QPoint focusMousePosition() const;
 
     AbstractClient* getMovingClient() {
         return movingClient;
     }
 
     /**
      * @returns Whether we have a Compositor and it is active (Scene created)
      **/
     bool compositing() const;
 
     void registerEventFilter(X11EventFilter *filter);
     void unregisterEventFilter(X11EventFilter *filter);
 
     void markXStackingOrderAsDirty();
 
     void quickTileWindow(QuickTileMode mode);
 
     enum Direction {
         DirectionNorth,
         DirectionEast,
         DirectionSouth,
         DirectionWest
     };
     void switchWindow(Direction direction);
 
 public Q_SLOTS:
     void performWindowOperation(KWin::AbstractClient* c, Options::WindowOperation op);
     // Keybindings
     //void slotSwitchToWindow( int );
     void slotWindowToDesktop(uint i);
 
     //void slotWindowToListPosition( int );
     void slotSwitchToScreen();
     void slotWindowToScreen();
     void slotSwitchToNextScreen();
     void slotWindowToNextScreen();
     void slotSwitchToPrevScreen();
     void slotWindowToPrevScreen();
     void slotToggleShowDesktop();
 
     void slotWindowMaximize();
     void slotWindowMaximizeVertical();
     void slotWindowMaximizeHorizontal();
     void slotWindowMinimize();
     void slotWindowShade();
     void slotWindowRaise();
     void slotWindowLower();
     void slotWindowRaiseOrLower();
     void slotActivateAttentionWindow();
     void slotWindowPackLeft();
     void slotWindowPackRight();
     void slotWindowPackUp();
     void slotWindowPackDown();
     void slotWindowGrowHorizontal();
     void slotWindowGrowVertical();
     void slotWindowShrinkHorizontal();
     void slotWindowShrinkVertical();
 
     void slotIncreaseWindowOpacity();
     void slotLowerWindowOpacity();
 
     void slotWindowOperations();
     void slotWindowClose();
     void slotWindowMove();
     void slotWindowResize();
     void slotWindowAbove();
     void slotWindowBelow();
     void slotWindowOnAllDesktops();
     void slotWindowFullScreen();
     void slotWindowNoBorder();
 
     void slotWindowToNextDesktop();
     void slotWindowToPreviousDesktop();
     void slotWindowToDesktopRight();
     void slotWindowToDesktopLeft();
     void slotWindowToDesktopUp();
     void slotWindowToDesktopDown();
 
     void reconfigure();
     void slotReconfigure();
 
     void slotKillWindow();
 
     void slotSetupWindowShortcut();
     void setupWindowShortcutDone(bool);
     void slotToggleCompositing();
     void slotInvertScreen();
 
     void updateClientArea();
 
     void slotActivateNextTab(); // Slot to move left the active Client.
     void slotActivatePrevTab(); // Slot to move right the active Client.
     void slotUntab(); // Slot to remove the active client from its group.
 
 private Q_SLOTS:
     void desktopResized();
     void selectWmInputEventMask();
     void slotUpdateToolWindows();
     void delayFocus();
     void slotReloadConfig();
     void updateCurrentActivity(const QString &new_activity);
     // virtual desktop handling
     void moveClientsFromRemovedDesktops();
     void slotDesktopCountChanged(uint previousCount, uint newCount);
     void slotCurrentDesktopChanged(uint oldDesktop, uint newDesktop);
 
     // session management
     void saveState(QSessionManager &sm);
     void commitData(QSessionManager &sm);
 
 Q_SIGNALS:
     /**
      * Emitted after the Workspace has setup the complete initialization process.
      * This can be used to connect to for performing post-workspace initialization.
      **/
     void workspaceInitialized();
 
     //Signals required for the scripting interface
     void desktopPresenceChanged(KWin::AbstractClient*, int);
     void currentDesktopChanged(int, KWin::AbstractClient*);
     void clientAdded(KWin::Client*);
     void clientRemoved(KWin::AbstractClient*);
     void clientActivated(KWin::AbstractClient*);
     void clientDemandsAttentionChanged(KWin::AbstractClient*, bool);
     void groupAdded(KWin::Group*);
     void unmanagedAdded(KWin::Unmanaged*);
     void unmanagedRemoved(KWin::Unmanaged*);
     void deletedRemoved(KWin::Deleted*);
     void propertyNotify(long a);
     void configChanged();
     void reinitializeCompositing();
     void showingDesktopChanged(bool showing);
     /**
      * This signels is emitted when ever the stacking order is change, ie. a window is risen
      * or lowered
      */
     void stackingOrderChanged();
 
 private:
     void init();
     void initShortcuts();
     template <typename Slot>
     void initShortcut(const QString &actionName, const QString &description, const QKeySequence &shortcut,
                       Slot slot, const QVariant &data = QVariant());
     void setupWindowShortcut(AbstractClient* c);
     bool switchWindow(AbstractClient *c, Direction direction, QPoint curPos, int desktop);
 
     void propagateClients(bool propagate_new_clients);   // Called only from updateStackingOrder
     ToplevelList constrainedStackingOrder();
     void raiseClientWithinApplication(AbstractClient* c);
     void lowerClientWithinApplication(AbstractClient* c);
     bool allowFullClientRaising(const AbstractClient* c, xcb_timestamp_t timestamp);
     bool keepTransientAbove(const AbstractClient* mainwindow, const AbstractClient* transient);
     void blockStackingUpdates(bool block);
     void updateToolWindows(bool also_hide);
     void fixPositionAfterCrash(xcb_window_t w, const xcb_get_geometry_reply_t *geom);
     void saveOldScreenSizes();
 
     /// This is the right way to create a new client
     Client* createClient(xcb_window_t w, bool is_mapped);
     void setupClientConnections(AbstractClient *client);
     void addClient(Client* c);
     Unmanaged* createUnmanaged(xcb_window_t w);
     void addUnmanaged(Unmanaged* c);
 
     //---------------------------------------------------------------------
 
     void closeActivePopup();
     void updateClientArea(bool force);
     void resetClientAreas(uint desktopCount);
     void updateClientVisibilityOnDesktopChange(uint oldDesktop, uint newDesktop);
     void activateClientOnNewDesktop(uint desktop);
     AbstractClient *findClientToActivateOnDesktop(uint desktop);
 
     QWidget* active_popup;
     AbstractClient* active_popup_client;
 
     int m_initialDesktop;
     void loadSessionInfo(const QString &key);
     void addSessionInfo(KConfigGroup &cg);
 
     QList<SessionInfo*> session;
     static const char* windowTypeToTxt(NET::WindowType type);
     static NET::WindowType txtToWindowType(const char* txt);
     static bool sessionInfoWindowTypeMatch(Client* c, SessionInfo* info);
 
     void updateXStackingOrder();
 
     AbstractClient* active_client;
     AbstractClient* last_active_client;
     AbstractClient* most_recently_raised; // Used ONLY by raiseOrLowerClient()
     AbstractClient* movingClient;
 
     // Delay(ed) window focus timer and client
     QTimer* delayFocusTimer;
     AbstractClient* delayfocus_client;
     QPoint focusMousePos;
 
     ClientList clients;
     QList<AbstractClient*> m_allClients;
     ClientList desktops;
     UnmanagedList unmanaged;
     DeletedList deleted;
 
     ToplevelList unconstrained_stacking_order; // Topmost last
     ToplevelList stacking_order; // Topmost last
     bool force_restacking;
     ToplevelList x_stacking; // From XQueryTree()
     std::unique_ptr<Xcb::Tree> m_xStackingQueryTree;
     QList<AbstractClient*> should_get_focus; // Last is most recent
     QList<AbstractClient*> attention_chain;
 
     bool showing_desktop;
 
     GroupList groups;
 
     bool was_user_interaction;
+    QScopedPointer<X11EventFilter> m_wasUserInteractionFilter;
     bool session_saving;
     int session_active_client;
     int session_desktop;
 
     int block_focus;
 
     /**
      * Holds the menu containing the user actions which is shown
      * on e.g. right click the window decoration.
      **/
     UserActionsMenu *m_userActionsMenu;
 
     void modalActionsSwitch(bool enabled);
 
     ShortcutDialog* client_keys_dialog;
     AbstractClient* client_keys_client;
     bool global_shortcuts_disabled_for_client;
 
     // Timer to collect requests for 'reconfigure'
     QTimer reconfigureTimer;
 
     QTimer updateToolWindowsTimer;
 
     static Workspace* _self;
 
     bool workspaceInit;
 
     KStartupInfo* startup;
 
     QVector<QRect> workarea; // Array of workareas for virtual desktops
     // Array of restricted areas that window cannot be moved into
     QVector<StrutRects> restrictedmovearea;
     // Array of the previous restricted areas that window cannot be moved into
     QVector<StrutRects> oldrestrictedmovearea;
     QVector< QVector<QRect> > screenarea; // Array of workareas per xinerama screen for all virtual desktops
     QVector< QRect > oldscreensizes; // array of previous sizes of xinerama screens
     QSize olddisplaysize; // previous sizes od displayWidth()/displayHeight()
 
     int set_active_client_recursion;
     int block_stacking_updates; // When > 0, stacking updates are temporarily disabled
     bool blocked_propagating_new_clients; // Propagate also new clients after enabling stacking updates?
     QScopedPointer<Xcb::Window> m_nullFocus;
     friend class StackingUpdatesBlocker;
 
     QScopedPointer<KillWindow> m_windowKiller;
 
     QList<X11EventFilter *> m_eventFilters;
     QList<X11EventFilter *> m_genericEventFilters;
 
 private:
     friend bool performTransiencyCheck();
     friend Workspace *workspace();
 };
 
 /**
  * Helper for Workspace::blockStackingUpdates() being called in pairs (True/false)
  */
 class StackingUpdatesBlocker
 {
 public:
     explicit StackingUpdatesBlocker(Workspace* w)
         : ws(w) {
         ws->blockStackingUpdates(true);
     }
     ~StackingUpdatesBlocker() {
         ws->blockStackingUpdates(false);
     }
 
 private:
     Workspace* ws;
 };
 
 class ColorMapper : public QObject
 {
     Q_OBJECT
 public:
     ColorMapper(QObject *parent);
     virtual ~ColorMapper();
 public Q_SLOTS:
     void update();
 private:
     xcb_colormap_t m_default;
     xcb_colormap_t m_installed;
 };
 
 //---------------------------------------------------------
 // Unsorted
 
 inline bool Workspace::initializing() const
 {
     return workspaceInit;
 }
 
 inline AbstractClient *Workspace::activeClient() const
 {
     return active_client;
 }
 
 inline AbstractClient *Workspace::mostRecentlyActivatedClient() const
 {
     return should_get_focus.count() > 0 ? should_get_focus.last() : active_client;
 }
 
 inline void Workspace::addGroup(Group* group)
 {
     emit groupAdded(group);
     groups.append(group);
 }
 
 inline void Workspace::removeGroup(Group* group)
 {
     groups.removeAll(group);
 }
 
 inline const ToplevelList& Workspace::stackingOrder() const
 {
     // TODO: Q_ASSERT( block_stacking_updates == 0 );
     return stacking_order;
 }
 
-inline void Workspace::setWasUserInteraction()
-{
-    was_user_interaction = true;
-}
-
 inline bool Workspace::wasUserInteraction() const
 {
     return was_user_interaction;
 }
 
 inline void Workspace::sessionSaveStarted()
 {
     session_saving = true;
 }
 
 inline bool Workspace::sessionSaving() const
 {
     return session_saving;
 }
 
 inline bool Workspace::showingDesktop() const
 {
     return showing_desktop;
 }
 
 inline bool Workspace::globalShortcutsDisabled() const
 {
     return global_shortcuts_disabled_for_client;
 }
 
 inline void Workspace::forceRestacking()
 {
     force_restacking = true;
     StackingUpdatesBlocker blocker(this);   // Do restacking if not blocked
 }
 
 inline void Workspace::updateFocusMousePosition(const QPoint& pos)
 {
     focusMousePos = pos;
 }
 
 inline QPoint Workspace::focusMousePosition() const
 {
     return focusMousePos;
 }
 
 inline
 void Workspace::forEachClient(std::function< void (Client*) > func)
 {
     std::for_each(clients.constBegin(), clients.constEnd(), func);
     std::for_each(desktops.constBegin(), desktops.constEnd(), func);
 }
 
 inline
 void Workspace::forEachUnmanaged(std::function< void (Unmanaged*) > func)
 {
     std::for_each(unmanaged.constBegin(), unmanaged.constEnd(), func);
 }
 
 inline bool Workspace::hasClient(const Client* c)
 {
     return findClient([c](const Client *test) {
         return test == c;
     });
 }
 
 inline Workspace *workspace()
 {
     return Workspace::_self;
 }
 
 } // namespace
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::Workspace::ActivityFlags)
 
 #endif